From e16868dede6455cab644805af6fe1ac312775e13 Mon Sep 17 00:00:00 2001 From: Gluster Ant Date: Wed, 12 Sep 2018 17:52:45 +0530 Subject: Land part 2 of clang-format changes Change-Id: Ia84cc24c8924e6d22d02ac15f611c10e26db99b4 Signed-off-by: Nigel Babu --- api/src/glfs-fops.c | 8474 +++++++++++++++++++++++----------------------- api/src/glfs-handleops.c | 3859 ++++++++++----------- api/src/glfs-master.c | 225 +- api/src/glfs-mgmt.c | 1818 +++++----- api/src/glfs-resolve.c | 1877 +++++----- api/src/glfs.c | 2370 +++++++------ 6 files changed, 9283 insertions(+), 9340 deletions(-) (limited to 'api/src') diff --git a/api/src/glfs-fops.c b/api/src/glfs-fops.c index 611cb14d9eb..f6786845a4f 100644 --- a/api/src/glfs-fops.c +++ b/api/src/glfs-fops.c @@ -33,23 +33,23 @@ #define READDIRBUF_SIZE (sizeof(struct dirent) + GF_NAME_MAX + 1) -typedef void (*glfs_io_cbk34) (glfs_fd_t *fd, ssize_t ret, void *data); +typedef void (*glfs_io_cbk34)(glfs_fd_t *fd, ssize_t ret, void *data); /* * This function will mark glfd for deletion and decrement its refcount. */ int -glfs_mark_glfd_for_deletion (struct glfs_fd *glfd) +glfs_mark_glfd_for_deletion(struct glfs_fd *glfd) { - LOCK (&glfd->lock); - { - glfd->state = GLFD_CLOSE; - } - UNLOCK (&glfd->lock); + LOCK(&glfd->lock); + { + glfd->state = GLFD_CLOSE; + } + UNLOCK(&glfd->lock); - GF_REF_PUT (glfd); + GF_REF_PUT(glfd); - return 0; + return 0; } /* This function is useful for all async fops. There is chance that glfd is @@ -60,33 +60,33 @@ glfs_mark_glfd_for_deletion (struct glfs_fd *glfd) * _gf_false. */ gf_boolean_t -glfs_is_glfd_still_valid (struct glfs_fd *glfd) +glfs_is_glfd_still_valid(struct glfs_fd *glfd) { - gf_boolean_t ret = _gf_false; + gf_boolean_t ret = _gf_false; - LOCK (&glfd->lock); - { - if (glfd->state != GLFD_CLOSE) - ret = _gf_true; - } - UNLOCK (&glfd->lock); + LOCK(&glfd->lock); + { + if (glfd->state != GLFD_CLOSE) + ret = _gf_true; + } + UNLOCK(&glfd->lock); - return ret; + return ret; } void -glfd_set_state_bind (struct glfs_fd *glfd) +glfd_set_state_bind(struct glfs_fd *glfd) { - LOCK (&glfd->lock); - { - glfd->state = GLFD_OPEN; - } - UNLOCK (&glfd->lock); + LOCK(&glfd->lock); + { + glfd->state = GLFD_OPEN; + } + UNLOCK(&glfd->lock); - fd_bind (glfd->fd); - glfs_fd_bind (glfd); + fd_bind(glfd->fd); + glfs_fd_bind(glfd); - return; + return; } /* @@ -97,4528 +97,4581 @@ glfd_set_state_bind (struct glfs_fd *glfd) * maintained by gfapi. */ int -glfs_get_upcall_cache_invalidation (struct gf_upcall *to_up_data, - struct gf_upcall *from_up_data) +glfs_get_upcall_cache_invalidation(struct gf_upcall *to_up_data, + struct gf_upcall *from_up_data) { + struct gf_upcall_cache_invalidation *ca_data = NULL; + struct gf_upcall_cache_invalidation *f_ca_data = NULL; + int ret = -1; - struct gf_upcall_cache_invalidation *ca_data = NULL; - struct gf_upcall_cache_invalidation *f_ca_data = NULL; - int ret = -1; - - GF_VALIDATE_OR_GOTO (THIS->name, to_up_data, out); - GF_VALIDATE_OR_GOTO (THIS->name, from_up_data, out); + GF_VALIDATE_OR_GOTO(THIS->name, to_up_data, out); + GF_VALIDATE_OR_GOTO(THIS->name, from_up_data, out); - f_ca_data = from_up_data->data; - GF_VALIDATE_OR_GOTO (THIS->name, f_ca_data, out); + f_ca_data = from_up_data->data; + GF_VALIDATE_OR_GOTO(THIS->name, f_ca_data, out); - ca_data = GF_CALLOC (1, sizeof(*ca_data), - glfs_mt_upcall_entry_t); + ca_data = GF_CALLOC(1, sizeof(*ca_data), glfs_mt_upcall_entry_t); - if (!ca_data) { - gf_msg (THIS->name, GF_LOG_ERROR, errno, - API_MSG_ALLOC_FAILED, - "Upcall entry allocation failed."); - goto out; - } + if (!ca_data) { + gf_msg(THIS->name, GF_LOG_ERROR, errno, API_MSG_ALLOC_FAILED, + "Upcall entry allocation failed."); + goto out; + } - to_up_data->data = ca_data; + to_up_data->data = ca_data; - ca_data->flags = f_ca_data->flags; - ca_data->expire_time_attr = f_ca_data->expire_time_attr; - ca_data->stat = f_ca_data->stat; - ca_data->p_stat = f_ca_data->p_stat; - ca_data->oldp_stat = f_ca_data->oldp_stat; + ca_data->flags = f_ca_data->flags; + ca_data->expire_time_attr = f_ca_data->expire_time_attr; + ca_data->stat = f_ca_data->stat; + ca_data->p_stat = f_ca_data->p_stat; + ca_data->oldp_stat = f_ca_data->oldp_stat; - ret = 0; + ret = 0; out: - return ret; + return ret; } int -glfs_get_upcall_lease (struct gf_upcall *to_up_data, - struct gf_upcall *from_up_data) +glfs_get_upcall_lease(struct gf_upcall *to_up_data, + struct gf_upcall *from_up_data) { + struct gf_upcall_recall_lease *ca_data = NULL; + struct gf_upcall_recall_lease *f_ca_data = NULL; + int ret = -1; - struct gf_upcall_recall_lease *ca_data = NULL; - struct gf_upcall_recall_lease *f_ca_data = NULL; - int ret = -1; - - GF_VALIDATE_OR_GOTO (THIS->name, to_up_data, out); - GF_VALIDATE_OR_GOTO (THIS->name, from_up_data, out); + GF_VALIDATE_OR_GOTO(THIS->name, to_up_data, out); + GF_VALIDATE_OR_GOTO(THIS->name, from_up_data, out); - f_ca_data = from_up_data->data; - GF_VALIDATE_OR_GOTO (THIS->name, f_ca_data, out); + f_ca_data = from_up_data->data; + GF_VALIDATE_OR_GOTO(THIS->name, f_ca_data, out); - ca_data = GF_CALLOC (1, sizeof(*ca_data), - glfs_mt_upcall_entry_t); + ca_data = GF_CALLOC(1, sizeof(*ca_data), glfs_mt_upcall_entry_t); - if (!ca_data) { - gf_msg (THIS->name, GF_LOG_ERROR, errno, - API_MSG_ALLOC_FAILED, - "Upcall entry allocation failed."); - goto out; - } + if (!ca_data) { + gf_msg(THIS->name, GF_LOG_ERROR, errno, API_MSG_ALLOC_FAILED, + "Upcall entry allocation failed."); + goto out; + } - to_up_data->data = ca_data; + to_up_data->data = ca_data; - ca_data->lease_type = f_ca_data->lease_type; - gf_uuid_copy (ca_data->tid, f_ca_data->tid); - ca_data->dict = f_ca_data->dict; + ca_data->lease_type = f_ca_data->lease_type; + gf_uuid_copy(ca_data->tid, f_ca_data->tid); + ca_data->dict = f_ca_data->dict; - ret = 0; + ret = 0; out: - return ret; + return ret; } int -glfs_loc_link (loc_t *loc, struct iatt *iatt) +glfs_loc_link(loc_t *loc, struct iatt *iatt) { - int ret = -1; - inode_t *old_inode = NULL; - uint64_t ctx_value = LOOKUP_NOT_NEEDED; - - if (!loc->inode) { - errno = EINVAL; - return -1; - } + int ret = -1; + inode_t *old_inode = NULL; + uint64_t ctx_value = LOOKUP_NOT_NEEDED; - old_inode = loc->inode; - - /* If the inode already exists in the cache, the inode - * returned here points to the existing one. We need - * to update loc.inode accordingly. - */ - loc->inode = inode_link (loc->inode, loc->parent, loc->name, iatt); - if (loc->inode) { - inode_ctx_set (loc->inode, THIS, &ctx_value); - inode_lookup (loc->inode); - inode_unref (old_inode); - ret = 0; - } else { - ret = -1; - } + if (!loc->inode) { + errno = EINVAL; + return -1; + } + + old_inode = loc->inode; + + /* If the inode already exists in the cache, the inode + * returned here points to the existing one. We need + * to update loc.inode accordingly. + */ + loc->inode = inode_link(loc->inode, loc->parent, loc->name, iatt); + if (loc->inode) { + inode_ctx_set(loc->inode, THIS, &ctx_value); + inode_lookup(loc->inode); + inode_unref(old_inode); + ret = 0; + } else { + ret = -1; + } - return ret; + return ret; } - void -glfs_iatt_to_stat (struct glfs *fs, struct iatt *iatt, struct stat *stat) +glfs_iatt_to_stat(struct glfs *fs, struct iatt *iatt, struct stat *stat) { - iatt_to_stat (iatt, stat); - stat->st_dev = fs->dev_id; + iatt_to_stat(iatt, stat); + stat->st_dev = fs->dev_id; } - int -glfs_loc_unlink (loc_t *loc) +glfs_loc_unlink(loc_t *loc) { - inode_unlink (loc->inode, loc->parent, loc->name); + inode_unlink(loc->inode, loc->parent, loc->name); - /* since glfs_h_* objects hold a reference to inode - * it is safe to keep lookup count to '0' */ - if (!inode_has_dentry (loc->inode)) - inode_forget (loc->inode, 0); + /* since glfs_h_* objects hold a reference to inode + * it is safe to keep lookup count to '0' */ + if (!inode_has_dentry(loc->inode)) + inode_forget(loc->inode, 0); - return 0; + return 0; } - struct glfs_fd * -pub_glfs_open (struct glfs *fs, const char *path, int flags) -{ - int ret = -1; - struct glfs_fd *glfd = NULL; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - int reval = 0; - dict_t *fop_attr = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - glfd = glfs_fd_new (fs); - if (!glfd) - goto out; +pub_glfs_open(struct glfs *fs, const char *path, int flags) +{ + int ret = -1; + struct glfs_fd *glfd = NULL; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + int reval = 0; + dict_t *fop_attr = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + glfd = glfs_fd_new(fs); + if (!glfd) + goto out; retry: - ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval); - - ESTALE_RETRY (ret, errno, reval, &loc, retry); - - if (ret) - goto out; - - if (IA_ISDIR (iatt.ia_type)) { - ret = -1; - errno = EISDIR; - goto out; - } - - if (!IA_ISREG (iatt.ia_type)) { - ret = -1; - errno = EINVAL; - goto out; - } - - if (glfd->fd) { - /* Retry. Safe to touch glfd->fd as we - still have not glfs_fd_bind() yet. - */ - fd_unref (glfd->fd); - glfd->fd = NULL; - } - - glfd->fd = fd_create (loc.inode, getpid()); - if (!glfd->fd) { - ret = -1; - errno = ENOMEM; - goto out; - } - glfd->fd->flags = flags; - - ret = get_fop_attr_thrd_key (&fop_attr); - if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); + ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval); - ret = syncop_open (subvol, &loc, flags, glfd->fd, fop_attr, NULL); - DECODE_SYNCOP_ERR (ret); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + if (ret) + goto out; + + if (IA_ISDIR(iatt.ia_type)) { + ret = -1; + errno = EISDIR; + goto out; + } + + if (!IA_ISREG(iatt.ia_type)) { + ret = -1; + errno = EINVAL; + goto out; + } + + if (glfd->fd) { + /* Retry. Safe to touch glfd->fd as we + still have not glfs_fd_bind() yet. + */ + fd_unref(glfd->fd); + glfd->fd = NULL; + } + + glfd->fd = fd_create(loc.inode, getpid()); + if (!glfd->fd) { + ret = -1; + errno = ENOMEM; + goto out; + } + glfd->fd->flags = flags; + + ret = get_fop_attr_thrd_key(&fop_attr); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); + + ret = syncop_open(subvol, &loc, flags, glfd->fd, fop_attr, NULL); + DECODE_SYNCOP_ERR(ret); + + ESTALE_RETRY(ret, errno, reval, &loc, retry); out: - loc_wipe (&loc); + loc_wipe(&loc); - if (fop_attr) - dict_unref (fop_attr); + if (fop_attr) + dict_unref(fop_attr); - if (ret && glfd) { - GF_REF_PUT (glfd); - glfd = NULL; - } else if (glfd) { - glfd_set_state_bind (glfd); - } + if (ret && glfd) { + GF_REF_PUT(glfd); + glfd = NULL; + } else if (glfd) { + glfd_set_state_bind(glfd); + } - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return glfd; + return glfd; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_open, 3.4.0); int -pub_glfs_close (struct glfs_fd *glfd) -{ - xlator_t *subvol = NULL; - int ret = -1; - fd_t *fd = NULL; - struct glfs *fs = NULL; - dict_t *fop_attr = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } - - if (glfd->lk_owner.len != 0) { - ret = syncopctx_setfslkowner (&glfd->lk_owner); - if (ret) - goto out; - } - ret = get_fop_attr_thrd_key (&fop_attr); +pub_glfs_close(struct glfs_fd *glfd) +{ + xlator_t *subvol = NULL; + int ret = -1; + fd_t *fd = NULL; + struct glfs *fs = NULL; + dict_t *fop_attr = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + if (glfd->lk_owner.len != 0) { + ret = syncopctx_setfslkowner(&glfd->lk_owner); if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); - - ret = syncop_flush (subvol, fd, fop_attr, NULL); - DECODE_SYNCOP_ERR (ret); + goto out; + } + ret = get_fop_attr_thrd_key(&fop_attr); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); + + ret = syncop_flush(subvol, fd, fop_attr, NULL); + DECODE_SYNCOP_ERR(ret); out: - fs = glfd->fs; - - if (fd) - fd_unref (fd); - if (fop_attr) - dict_unref (fop_attr); + fs = glfd->fs; + if (fd) + fd_unref(fd); + if (fop_attr) + dict_unref(fop_attr); - glfs_mark_glfd_for_deletion (glfd); - glfs_subvol_done (fs, subvol); + glfs_mark_glfd_for_deletion(glfd); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_close, 3.4.0); - int -pub_glfs_lstat (struct glfs *fs, const char *path, struct stat *stat) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +pub_glfs_lstat(struct glfs *fs, const char *path, struct stat *stat) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval); + ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret == 0 && stat) - glfs_iatt_to_stat (fs, &iatt, stat); + if (ret == 0 && stat) + glfs_iatt_to_stat(fs, &iatt, stat); out: - loc_wipe (&loc); + loc_wipe(&loc); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lstat, 3.4.0); - int -pub_glfs_stat (struct glfs *fs, const char *path, struct stat *stat) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +pub_glfs_stat(struct glfs *fs, const char *path, struct stat *stat) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval); + ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret == 0 && stat) - glfs_iatt_to_stat (fs, &iatt, stat); + if (ret == 0 && stat) + glfs_iatt_to_stat(fs, &iatt, stat); out: - loc_wipe (&loc); + loc_wipe(&loc); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_stat, 3.4.0); - int -pub_glfs_fstat (struct glfs_fd *glfd, struct stat *stat) -{ - int ret = -1; - xlator_t *subvol = NULL; - struct iatt iatt = {0, }; - fd_t *fd = NULL; +pub_glfs_fstat(struct glfs_fd *glfd, struct stat *stat) +{ + int ret = -1; + xlator_t *subvol = NULL; + struct iatt iatt = { + 0, + }; + fd_t *fd = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + ret = syncop_fstat(subvol, fd, &iatt, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + + if (ret == 0 && stat) + glfs_iatt_to_stat(glfd->fs, &iatt, stat); +out: + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); + glfs_subvol_done(glfd->fs, subvol); - GF_REF_GET (glfd); + __GLFS_EXIT_FS; - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +invalid_fs: + return ret; +} - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } +GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fstat, 3.4.0); - ret = syncop_fstat (subvol, fd, &iatt, NULL, NULL); - DECODE_SYNCOP_ERR (ret); +struct glfs_fd * +pub_glfs_creat(struct glfs *fs, const char *path, int flags, mode_t mode) +{ + int ret = -1; + struct glfs_fd *glfd = NULL; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + uuid_t gfid; + dict_t *xattr_req = NULL; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + xattr_req = dict_new(); + if (!xattr_req) { + ret = -1; + errno = ENOMEM; + goto out; + } + + gf_uuid_generate(gfid); + ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true); + if (ret) { + ret = -1; + errno = ENOMEM; + goto out; + } + + glfd = glfs_fd_new(fs); + if (!glfd) + goto out; + + /* This must be glfs_resolve() and NOT glfs_lresolve(). + That is because open("name", O_CREAT) where "name" + is a danging symlink must create the dangling + destination. + */ +retry: + ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval); - if (ret == 0 && stat) - glfs_iatt_to_stat (glfd->fs, &iatt, stat); -out: - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - glfs_subvol_done (glfd->fs, subvol); + if (ret == -1 && errno != ENOENT) + /* Any other type of error is fatal */ + goto out; - __GLFS_EXIT_FS; + if (ret == -1 && errno == ENOENT && !loc.parent) + /* The parent directory or an ancestor even + higher does not exist + */ + goto out; -invalid_fs: - return ret; -} + if (loc.inode) { + if (flags & O_EXCL) { + ret = -1; + errno = EEXIST; + goto out; + } -GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fstat, 3.4.0); + if (IA_ISDIR(iatt.ia_type)) { + ret = -1; + errno = EISDIR; + goto out; + } + if (!IA_ISREG(iatt.ia_type)) { + ret = -1; + errno = EINVAL; + goto out; + } + } + + if (ret == -1 && errno == ENOENT) { + loc.inode = inode_new(loc.parent->table); + if (!loc.inode) { + ret = -1; + errno = ENOMEM; + goto out; + } + } -struct glfs_fd * -pub_glfs_creat (struct glfs *fs, const char *path, int flags, mode_t mode) -{ - int ret = -1; - struct glfs_fd *glfd = NULL; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - uuid_t gfid; - dict_t *xattr_req = NULL; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - xattr_req = dict_new (); - if (!xattr_req) { - ret = -1; - errno = ENOMEM; - goto out; - } - - gf_uuid_generate (gfid); - ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true); - if (ret) { - ret = -1; - errno = ENOMEM; - goto out; - } - - glfd = glfs_fd_new (fs); - if (!glfd) - goto out; - - /* This must be glfs_resolve() and NOT glfs_lresolve(). - That is because open("name", O_CREAT) where "name" - is a danging symlink must create the dangling - destination. - */ -retry: - ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval); - - ESTALE_RETRY (ret, errno, reval, &loc, retry); - - if (ret == -1 && errno != ENOENT) - /* Any other type of error is fatal */ - goto out; - - if (ret == -1 && errno == ENOENT && !loc.parent) - /* The parent directory or an ancestor even - higher does not exist - */ - goto out; - - if (loc.inode) { - if (flags & O_EXCL) { - ret = -1; - errno = EEXIST; - goto out; - } - - if (IA_ISDIR (iatt.ia_type)) { - ret = -1; - errno = EISDIR; - goto out; - } - - if (!IA_ISREG (iatt.ia_type)) { - ret = -1; - errno = EINVAL; - goto out; - } - } - - if (ret == -1 && errno == ENOENT) { - loc.inode = inode_new (loc.parent->table); - if (!loc.inode) { - ret = -1; - errno = ENOMEM; - goto out; - } - } - - if (glfd->fd) { - /* Retry. Safe to touch glfd->fd as we - still have not glfs_fd_bind() yet. - */ - fd_unref (glfd->fd); - glfd->fd = NULL; - } - - glfd->fd = fd_create (loc.inode, getpid()); - if (!glfd->fd) { - ret = -1; - errno = ENOMEM; - goto out; - } - glfd->fd->flags = flags; - - if (get_fop_attr_thrd_key (&xattr_req)) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); - if (ret == 0) { - ret = syncop_open (subvol, &loc, flags, glfd->fd, xattr_req, NULL); - DECODE_SYNCOP_ERR (ret); - } else { - ret = syncop_create (subvol, &loc, flags, mode, glfd->fd, - &iatt, xattr_req, NULL); - DECODE_SYNCOP_ERR (ret); - } - - ESTALE_RETRY (ret, errno, reval, &loc, retry); - - if (ret == 0) - ret = glfs_loc_link (&loc, &iatt); + if (glfd->fd) { + /* Retry. Safe to touch glfd->fd as we + still have not glfs_fd_bind() yet. + */ + fd_unref(glfd->fd); + glfd->fd = NULL; + } + + glfd->fd = fd_create(loc.inode, getpid()); + if (!glfd->fd) { + ret = -1; + errno = ENOMEM; + goto out; + } + glfd->fd->flags = flags; + + if (get_fop_attr_thrd_key(&xattr_req)) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); + if (ret == 0) { + ret = syncop_open(subvol, &loc, flags, glfd->fd, xattr_req, NULL); + DECODE_SYNCOP_ERR(ret); + } else { + ret = syncop_create(subvol, &loc, flags, mode, glfd->fd, &iatt, + xattr_req, NULL); + DECODE_SYNCOP_ERR(ret); + } + + ESTALE_RETRY(ret, errno, reval, &loc, retry); + + if (ret == 0) + ret = glfs_loc_link(&loc, &iatt); out: - loc_wipe (&loc); + loc_wipe(&loc); - if (xattr_req) - dict_unref (xattr_req); + if (xattr_req) + dict_unref(xattr_req); - if (ret && glfd) { - GF_REF_PUT (glfd); - glfd = NULL; - } else if (glfd) { - glfd_set_state_bind (glfd); - } + if (ret && glfd) { + GF_REF_PUT(glfd); + glfd = NULL; + } else if (glfd) { + glfd_set_state_bind(glfd); + } - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return glfd; + return glfd; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_creat, 3.4.0); #ifdef HAVE_SEEK_HOLE static int -glfs_seek (struct glfs_fd *glfd, off_t offset, int whence) +glfs_seek(struct glfs_fd *glfd, off_t offset, int whence) { - int ret = -1; - xlator_t *subvol = NULL; - fd_t *fd = NULL; - gf_seek_what_t what = 0; - off_t off = -1; + int ret = -1; + xlator_t *subvol = NULL; + fd_t *fd = NULL; + gf_seek_what_t what = 0; + off_t off = -1; - switch (whence) { + switch (whence) { case SEEK_DATA: - what = GF_SEEK_DATA; - break; + what = GF_SEEK_DATA; + break; case SEEK_HOLE: - what = GF_SEEK_HOLE; - break; + what = GF_SEEK_HOLE; + break; default: - /* other SEEK_* do not make sense, all operations get an offset - * and the position in the fd is not tracked */ - errno = EINVAL; - goto out; - } - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - errno = EBADFD; - goto done; - } - - ret = syncop_seek (subvol, fd, offset, what, NULL, &off); - DECODE_SYNCOP_ERR (ret); - - if (ret != -1) - glfd->offset = off; + /* other SEEK_* do not make sense, all operations get an offset + * and the position in the fd is not tracked */ + errno = EINVAL; + goto out; + } + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + errno = EBADFD; + goto done; + } + + ret = syncop_seek(subvol, fd, offset, what, NULL, &off); + DECODE_SYNCOP_ERR(ret); + + if (ret != -1) + glfd->offset = off; done: - if (fd) - fd_unref (fd); + if (fd) + fd_unref(fd); - glfs_subvol_done (glfd->fs, subvol); + glfs_subvol_done(glfd->fs, subvol); out: - return ret; + return ret; } #endif off_t -pub_glfs_lseek (struct glfs_fd *glfd, off_t offset, int whence) -{ - struct stat sb = {0, }; - int ret = -1; - off_t off = -1; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - GF_REF_GET (glfd); - - switch (whence) { - case SEEK_SET: - glfd->offset = offset; - ret = 0; - break; - case SEEK_CUR: - glfd->offset += offset; - ret = 0; - break; - case SEEK_END: - ret = pub_glfs_fstat (glfd, &sb); - if (ret) { - /* seek cannot fail :O */ - break; - } - glfd->offset = sb.st_size + offset; - break; +pub_glfs_lseek(struct glfs_fd *glfd, off_t offset, int whence) +{ + struct stat sb = { + 0, + }; + int ret = -1; + off_t off = -1; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + switch (whence) { + case SEEK_SET: + glfd->offset = offset; + ret = 0; + break; + case SEEK_CUR: + glfd->offset += offset; + ret = 0; + break; + case SEEK_END: + ret = pub_glfs_fstat(glfd, &sb); + if (ret) { + /* seek cannot fail :O */ + break; + } + glfd->offset = sb.st_size + offset; + break; #ifdef HAVE_SEEK_HOLE case SEEK_DATA: case SEEK_HOLE: - ret = glfs_seek (glfd, offset, whence); - break; + ret = glfs_seek(glfd, offset, whence); + break; #endif default: - errno = EINVAL; - } + errno = EINVAL; + } - if (glfd) - GF_REF_PUT (glfd); + if (glfd) + GF_REF_PUT(glfd); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; - if (ret != -1) - off = glfd->offset; + if (ret != -1) + off = glfd->offset; - return off; + return off; invalid_fs: - return -1; + return -1; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lseek, 3.4.0); - static ssize_t -glfs_preadv_common (struct glfs_fd *glfd, const struct iovec *iovec, - int iovcnt, off_t offset, int flags, struct stat *poststat) -{ - xlator_t *subvol = NULL; - ssize_t ret = -1; - ssize_t size = -1; - struct iovec *iov = NULL; - int cnt = 0; - struct iobref *iobref = NULL; - fd_t *fd = NULL; - struct iatt iatt = {0, }; - dict_t *fop_attr = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - GF_REF_GET (glfd); - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } - - size = iov_length (iovec, iovcnt); - - ret = get_fop_attr_thrd_key (&fop_attr); - if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); +glfs_preadv_common(struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt, + off_t offset, int flags, struct stat *poststat) +{ + xlator_t *subvol = NULL; + ssize_t ret = -1; + ssize_t size = -1; + struct iovec *iov = NULL; + int cnt = 0; + struct iobref *iobref = NULL; + fd_t *fd = NULL; + struct iatt iatt = { + 0, + }; + dict_t *fop_attr = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + size = iov_length(iovec, iovcnt); - ret = syncop_readv (subvol, fd, size, offset, 0, &iov, &cnt, &iobref, - &iatt, fop_attr, NULL); - DECODE_SYNCOP_ERR (ret); + ret = get_fop_attr_thrd_key(&fop_attr); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); - if (ret >= 0 && poststat) - glfs_iatt_to_stat (glfd->fs, &iatt, poststat); + ret = syncop_readv(subvol, fd, size, offset, 0, &iov, &cnt, &iobref, &iatt, + fop_attr, NULL); + DECODE_SYNCOP_ERR(ret); - if (ret <= 0) - goto out; + if (ret >= 0 && poststat) + glfs_iatt_to_stat(glfd->fs, &iatt, poststat); - size = iov_copy (iovec, iovcnt, iov, cnt); /* FIXME!!! */ + if (ret <= 0) + goto out; - glfd->offset = (offset + size); + size = iov_copy(iovec, iovcnt, iov, cnt); /* FIXME!!! */ - ret = size; + glfd->offset = (offset + size); + + ret = size; out: - if (iov) - GF_FREE (iov); - if (iobref) - iobref_unref (iobref); + if (iov) + GF_FREE(iov); + if (iobref) + iobref_unref(iobref); - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); - if (fop_attr) - dict_unref (fop_attr); + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); + if (fop_attr) + dict_unref(fop_attr); - glfs_subvol_done (glfd->fs, subvol); + glfs_subvol_done(glfd->fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } ssize_t -pub_glfs_preadv (struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt, - off_t offset, int flags) +pub_glfs_preadv(struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt, + off_t offset, int flags) { - return glfs_preadv_common (glfd, iovec, iovcnt, offset, flags, NULL); + return glfs_preadv_common(glfd, iovec, iovcnt, offset, flags, NULL); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_preadv, 3.4.0); - ssize_t -pub_glfs_read (struct glfs_fd *glfd, void *buf, size_t count, int flags) +pub_glfs_read(struct glfs_fd *glfd, void *buf, size_t count, int flags) { - struct iovec iov = {0, }; - ssize_t ret = 0; + struct iovec iov = { + 0, + }; + ssize_t ret = 0; - iov.iov_base = buf; - iov.iov_len = count; + iov.iov_base = buf; + iov.iov_len = count; - ret = pub_glfs_preadv (glfd, &iov, 1, glfd->offset, flags); + ret = pub_glfs_preadv(glfd, &iov, 1, glfd->offset, flags); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_read, 3.4.0); - ssize_t -pub_glfs_pread34 (struct glfs_fd *glfd, void *buf, size_t count, off_t offset, - int flags) +pub_glfs_pread34(struct glfs_fd *glfd, void *buf, size_t count, off_t offset, + int flags) { - struct iovec iov = {0, }; - ssize_t ret = 0; + struct iovec iov = { + 0, + }; + ssize_t ret = 0; - iov.iov_base = buf; - iov.iov_len = count; + iov.iov_base = buf; + iov.iov_len = count; - ret = pub_glfs_preadv (glfd, &iov, 1, offset, flags); + ret = pub_glfs_preadv(glfd, &iov, 1, offset, flags); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC(glfs_pread34, glfs_pread, 3.4.0); - ssize_t -pub_glfs_pread (struct glfs_fd *glfd, void *buf, size_t count, off_t offset, - int flags, struct stat *poststat) +pub_glfs_pread(struct glfs_fd *glfd, void *buf, size_t count, off_t offset, + int flags, struct stat *poststat) { - struct iovec iov = {0, }; - ssize_t ret = 0; + struct iovec iov = { + 0, + }; + ssize_t ret = 0; - iov.iov_base = buf; - iov.iov_len = count; + iov.iov_base = buf; + iov.iov_len = count; - ret = glfs_preadv_common (glfd, &iov, 1, offset, flags, poststat); + ret = glfs_preadv_common(glfd, &iov, 1, offset, flags, poststat); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pread, future); - ssize_t -pub_glfs_readv (struct glfs_fd *glfd, const struct iovec *iov, int count, - int flags) +pub_glfs_readv(struct glfs_fd *glfd, const struct iovec *iov, int count, + int flags) { - ssize_t ret = 0; + ssize_t ret = 0; - ret = pub_glfs_preadv (glfd, iov, count, glfd->offset, flags); + ret = pub_glfs_preadv(glfd, iov, count, glfd->offset, flags); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readv, 3.4.0); - struct glfs_io { - struct glfs_fd *glfd; - int op; - off_t offset; - struct iovec *iov; - int count; - int flags; - gf_boolean_t oldcb; - union { - glfs_io_cbk34 fn34; - glfs_io_cbk fn; - }; - void *data; + struct glfs_fd *glfd; + int op; + off_t offset; + struct iovec *iov; + int count; + int flags; + gf_boolean_t oldcb; + union { + glfs_io_cbk34 fn34; + glfs_io_cbk fn; + }; + void *data; }; - static int -glfs_io_async_cbk (int op_ret, int op_errno, call_frame_t *frame, - void *cookie, struct iovec *iovec, int count, - struct iatt *prebuf, struct iatt *postbuf) -{ - struct glfs_io *gio = NULL; - xlator_t *subvol = NULL; - struct glfs *fs = NULL; - struct glfs_fd *glfd = NULL; - int ret = -1; - struct stat prestat = {}, *prestatp = NULL; - struct stat poststat = {}, *poststatp = NULL; - - GF_VALIDATE_OR_GOTO ("gfapi", frame, inval); - GF_VALIDATE_OR_GOTO ("gfapi", cookie, inval); - - gio = frame->local; - frame->local = NULL; - subvol = cookie; - glfd = gio->glfd; - fs = glfd->fs; - - if (!glfs_is_glfd_still_valid (glfd)) - goto err; - - if (op_ret <= 0) { - goto out; - } else if (gio->op == GF_FOP_READ) { - if (!iovec) { - op_ret = -1; - op_errno = EINVAL; - goto out; - } - - op_ret = iov_copy (gio->iov, gio->count, iovec, count); - glfd->offset = gio->offset + op_ret; - } else if (gio->op == GF_FOP_WRITE) { - glfd->offset = gio->offset + gio->iov->iov_len; +glfs_io_async_cbk(int op_ret, int op_errno, call_frame_t *frame, void *cookie, + struct iovec *iovec, int count, struct iatt *prebuf, + struct iatt *postbuf) +{ + struct glfs_io *gio = NULL; + xlator_t *subvol = NULL; + struct glfs *fs = NULL; + struct glfs_fd *glfd = NULL; + int ret = -1; + struct stat prestat = {}, *prestatp = NULL; + struct stat poststat = {}, *poststatp = NULL; + + GF_VALIDATE_OR_GOTO("gfapi", frame, inval); + GF_VALIDATE_OR_GOTO("gfapi", cookie, inval); + + gio = frame->local; + frame->local = NULL; + subvol = cookie; + glfd = gio->glfd; + fs = glfd->fs; + + if (!glfs_is_glfd_still_valid(glfd)) + goto err; + + if (op_ret <= 0) { + goto out; + } else if (gio->op == GF_FOP_READ) { + if (!iovec) { + op_ret = -1; + op_errno = EINVAL; + goto out; } -out: - errno = op_errno; - if (gio->oldcb) { - gio->fn34 (gio->glfd, op_ret, gio->data); - } else { - if (prebuf) { - prestatp = &prestat; - glfs_iatt_to_stat (fs, prebuf, prestatp); - } - - if (postbuf) { - poststatp = &poststat; - glfs_iatt_to_stat (fs, postbuf, poststatp); - } + op_ret = iov_copy(gio->iov, gio->count, iovec, count); + glfd->offset = gio->offset + op_ret; + } else if (gio->op == GF_FOP_WRITE) { + glfd->offset = gio->offset + gio->iov->iov_len; + } - gio->fn (gio->glfd, op_ret, prestatp, poststatp, gio->data); +out: + errno = op_errno; + if (gio->oldcb) { + gio->fn34(gio->glfd, op_ret, gio->data); + } else { + if (prebuf) { + prestatp = &prestat; + glfs_iatt_to_stat(fs, prebuf, prestatp); } -err: - fd_unref (glfd->fd); - /* Since the async operation is complete - * release the ref taken during the start - * of async operation - */ - GF_REF_PUT (glfd); - GF_FREE (gio->iov); - GF_FREE (gio); - STACK_DESTROY (frame->root); - glfs_subvol_done (fs, subvol); + if (postbuf) { + poststatp = &poststat; + glfs_iatt_to_stat(fs, postbuf, poststatp); + } - ret = 0; + gio->fn(gio->glfd, op_ret, prestatp, poststatp, gio->data); + } +err: + fd_unref(glfd->fd); + /* Since the async operation is complete + * release the ref taken during the start + * of async operation + */ + GF_REF_PUT(glfd); + + GF_FREE(gio->iov); + GF_FREE(gio); + STACK_DESTROY(frame->root); + glfs_subvol_done(fs, subvol); + + ret = 0; inval: - return ret; + return ret; } static int -glfs_preadv_async_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, struct iovec *iovec, - int count, struct iatt *stbuf, struct iobref *iobref, - dict_t *xdata) +glfs_preadv_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, struct iovec *iovec, int count, + struct iatt *stbuf, struct iobref *iobref, dict_t *xdata) { - glfs_io_async_cbk (op_ret, op_errno, frame, cookie, iovec, count, - NULL, stbuf); + glfs_io_async_cbk(op_ret, op_errno, frame, cookie, iovec, count, NULL, + stbuf); - return 0; + return 0; } - static int -glfs_preadv_async_common (struct glfs_fd *glfd, const struct iovec *iovec, - int count, off_t offset, int flags, - gf_boolean_t oldcb, glfs_io_cbk fn, void *data) +glfs_preadv_async_common(struct glfs_fd *glfd, const struct iovec *iovec, + int count, off_t offset, int flags, gf_boolean_t oldcb, + glfs_io_cbk fn, void *data) { - struct glfs_io *gio = NULL; - int ret = 0; - call_frame_t *frame = NULL; - xlator_t *subvol = NULL; - struct glfs *fs = NULL; - fd_t *fd = NULL; - dict_t *fop_attr = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - GF_REF_GET (glfd); - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } - - fs = glfd->fs; - - frame = syncop_create_frame (THIS); - if (!frame) { - ret = -1; - errno = ENOMEM; - goto out; - } - - gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t); - if (!gio) { - ret = -1; - errno = ENOMEM; - goto out; - } - - gio->iov = iov_dup (iovec, count); - if (!gio->iov) { - ret = -1; - errno = ENOMEM; - goto out; - } - - gio->op = GF_FOP_READ; - gio->glfd = glfd; - gio->count = count; - gio->offset = offset; - gio->flags = flags; - gio->oldcb = oldcb; - gio->fn = fn; - gio->data = data; - - frame->local = gio; - - ret = get_fop_attr_thrd_key (&fop_attr); - if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); - - STACK_WIND_COOKIE (frame, glfs_preadv_async_cbk, subvol, subvol, - subvol->fops->readv, fd, iov_length (iovec, count), - offset, flags, fop_attr); + struct glfs_io *gio = NULL; + int ret = 0; + call_frame_t *frame = NULL; + xlator_t *subvol = NULL; + struct glfs *fs = NULL; + fd_t *fd = NULL; + dict_t *fop_attr = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + fs = glfd->fs; + + frame = syncop_create_frame(THIS); + if (!frame) { + ret = -1; + errno = ENOMEM; + goto out; + } + + gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t); + if (!gio) { + ret = -1; + errno = ENOMEM; + goto out; + } + + gio->iov = iov_dup(iovec, count); + if (!gio->iov) { + ret = -1; + errno = ENOMEM; + goto out; + } + + gio->op = GF_FOP_READ; + gio->glfd = glfd; + gio->count = count; + gio->offset = offset; + gio->flags = flags; + gio->oldcb = oldcb; + gio->fn = fn; + gio->data = data; + + frame->local = gio; + + ret = get_fop_attr_thrd_key(&fop_attr); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); + + STACK_WIND_COOKIE(frame, glfs_preadv_async_cbk, subvol, subvol, + subvol->fops->readv, fd, iov_length(iovec, count), offset, + flags, fop_attr); out: - if (ret) { - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); - if (gio) { - GF_FREE (gio->iov); - GF_FREE (gio); - } - if (frame) { - STACK_DESTROY (frame->root); - } - glfs_subvol_done (fs, subvol); - } - if (fop_attr) - dict_unref (fop_attr); + if (ret) { + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); + if (gio) { + GF_FREE(gio->iov); + GF_FREE(gio); + } + if (frame) { + STACK_DESTROY(frame->root); + } + glfs_subvol_done(fs, subvol); + } + if (fop_attr) + dict_unref(fop_attr); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; - return ret; + return ret; invalid_fs: - return -1; + return -1; } int -pub_glfs_preadv_async34 (struct glfs_fd *glfd, const struct iovec *iovec, - int count, off_t offset, int flags, glfs_io_cbk34 fn, - void *data) +pub_glfs_preadv_async34(struct glfs_fd *glfd, const struct iovec *iovec, + int count, off_t offset, int flags, glfs_io_cbk34 fn, + void *data) { - return glfs_preadv_async_common (glfd, iovec, count, offset, flags, - _gf_true, (void *)fn, data); + return glfs_preadv_async_common(glfd, iovec, count, offset, flags, _gf_true, + (void *)fn, data); } GFAPI_SYMVER_PUBLIC(glfs_preadv_async34, glfs_preadv_async, 3.4.0); - int -pub_glfs_preadv_async (struct glfs_fd *glfd, const struct iovec *iovec, - int count, off_t offset, int flags, glfs_io_cbk fn, - void *data) +pub_glfs_preadv_async(struct glfs_fd *glfd, const struct iovec *iovec, + int count, off_t offset, int flags, glfs_io_cbk fn, + void *data) { - return glfs_preadv_async_common (glfd, iovec, count, offset, flags, - _gf_false, fn, data); + return glfs_preadv_async_common(glfd, iovec, count, offset, flags, + _gf_false, fn, data); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_preadv_async, future); - int -pub_glfs_read_async34 (struct glfs_fd *glfd, void *buf, size_t count, int flags, - glfs_io_cbk34 fn, void *data) +pub_glfs_read_async34(struct glfs_fd *glfd, void *buf, size_t count, int flags, + glfs_io_cbk34 fn, void *data) { - struct iovec iov = {0, }; - ssize_t ret = 0; + struct iovec iov = { + 0, + }; + ssize_t ret = 0; - iov.iov_base = buf; - iov.iov_len = count; + iov.iov_base = buf; + iov.iov_len = count; - ret = glfs_preadv_async_common (glfd, &iov, 1, glfd->offset, flags, - _gf_true, (void *)fn, data); + ret = glfs_preadv_async_common(glfd, &iov, 1, glfd->offset, flags, _gf_true, + (void *)fn, data); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC(glfs_read_async34, glfs_read_async, 3.4.0); - int -pub_glfs_read_async (struct glfs_fd *glfd, void *buf, size_t count, int flags, - glfs_io_cbk fn, void *data) +pub_glfs_read_async(struct glfs_fd *glfd, void *buf, size_t count, int flags, + glfs_io_cbk fn, void *data) { - struct iovec iov = {0, }; - ssize_t ret = 0; + struct iovec iov = { + 0, + }; + ssize_t ret = 0; - iov.iov_base = buf; - iov.iov_len = count; + iov.iov_base = buf; + iov.iov_len = count; - ret = glfs_preadv_async_common (glfd, &iov, 1, glfd->offset, flags, - _gf_false, fn, data); + ret = glfs_preadv_async_common(glfd, &iov, 1, glfd->offset, flags, + _gf_false, fn, data); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_read_async, future); - int -pub_glfs_pread_async34 (struct glfs_fd *glfd, void *buf, size_t count, - off_t offset, int flags, glfs_io_cbk34 fn, void *data) +pub_glfs_pread_async34(struct glfs_fd *glfd, void *buf, size_t count, + off_t offset, int flags, glfs_io_cbk34 fn, void *data) { - struct iovec iov = {0, }; - ssize_t ret = 0; + struct iovec iov = { + 0, + }; + ssize_t ret = 0; - iov.iov_base = buf; - iov.iov_len = count; + iov.iov_base = buf; + iov.iov_len = count; - ret = glfs_preadv_async_common (glfd, &iov, 1, offset, flags, - _gf_true, (void *)fn, data); + ret = glfs_preadv_async_common(glfd, &iov, 1, offset, flags, _gf_true, + (void *)fn, data); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC(glfs_pread_async34, glfs_pread_async, 3.4.0); - int -pub_glfs_pread_async (struct glfs_fd *glfd, void *buf, size_t count, - off_t offset, int flags, glfs_io_cbk fn, void *data) +pub_glfs_pread_async(struct glfs_fd *glfd, void *buf, size_t count, + off_t offset, int flags, glfs_io_cbk fn, void *data) { - struct iovec iov = {0, }; - ssize_t ret = 0; + struct iovec iov = { + 0, + }; + ssize_t ret = 0; - iov.iov_base = buf; - iov.iov_len = count; + iov.iov_base = buf; + iov.iov_len = count; - ret = glfs_preadv_async_common (glfd, &iov, 1, offset, flags, - _gf_false, fn, data); + ret = glfs_preadv_async_common(glfd, &iov, 1, offset, flags, _gf_false, fn, + data); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pread_async, future); - int -pub_glfs_readv_async34 (struct glfs_fd *glfd, const struct iovec *iov, - int count, int flags, glfs_io_cbk34 fn, void *data) +pub_glfs_readv_async34(struct glfs_fd *glfd, const struct iovec *iov, int count, + int flags, glfs_io_cbk34 fn, void *data) { - ssize_t ret = 0; + ssize_t ret = 0; - ret = glfs_preadv_async_common (glfd, iov, count, glfd->offset, flags, - _gf_true, (void *)fn, data); - return ret; + ret = glfs_preadv_async_common(glfd, iov, count, glfd->offset, flags, + _gf_true, (void *)fn, data); + return ret; } GFAPI_SYMVER_PUBLIC(glfs_readv_async34, glfs_readv_async, 3.4.0); - int -pub_glfs_readv_async (struct glfs_fd *glfd, const struct iovec *iov, int count, - int flags, glfs_io_cbk fn, void *data) +pub_glfs_readv_async(struct glfs_fd *glfd, const struct iovec *iov, int count, + int flags, glfs_io_cbk fn, void *data) { - ssize_t ret = 0; + ssize_t ret = 0; - ret = glfs_preadv_async_common (glfd, iov, count, glfd->offset, flags, - _gf_false, fn, data); - return ret; + ret = glfs_preadv_async_common(glfd, iov, count, glfd->offset, flags, + _gf_false, fn, data); + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readv_async, future); static ssize_t -glfs_pwritev_common (struct glfs_fd *glfd, const struct iovec *iovec, - int iovcnt, off_t offset, int flags, - struct stat *prestat, struct stat *poststat) -{ - xlator_t *subvol = NULL; - int ret = -1; - struct iobref *iobref = NULL; - struct iobuf *iobuf = NULL; - struct iovec iov = {0, }; - fd_t *fd = NULL; - struct iatt preiatt = {0, }, postiatt = {0, }; - dict_t *fop_attr = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - GF_REF_GET (glfd); - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } - - ret = iobuf_copy (subvol->ctx->iobuf_pool, iovec, iovcnt, &iobref, - &iobuf, &iov); - if (ret) - goto out; - - ret = get_fop_attr_thrd_key (&fop_attr); - if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); - - ret = syncop_writev (subvol, fd, &iov, 1, offset, iobref, flags, - &preiatt, &postiatt, fop_attr, NULL); - DECODE_SYNCOP_ERR (ret); - - if (ret >= 0) { - if (prestat) - glfs_iatt_to_stat (glfd->fs, &preiatt, prestat); - if (poststat) - glfs_iatt_to_stat (glfd->fs, &postiatt, poststat); - } - - if (ret <= 0) - goto out; - - glfd->offset = (offset + iov.iov_len); +glfs_pwritev_common(struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt, + off_t offset, int flags, struct stat *prestat, + struct stat *poststat) +{ + xlator_t *subvol = NULL; + int ret = -1; + struct iobref *iobref = NULL; + struct iobuf *iobuf = NULL; + struct iovec iov = { + 0, + }; + fd_t *fd = NULL; + struct iatt preiatt = + { + 0, + }, + postiatt = { + 0, + }; + dict_t *fop_attr = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + ret = iobuf_copy(subvol->ctx->iobuf_pool, iovec, iovcnt, &iobref, &iobuf, + &iov); + if (ret) + goto out; + + ret = get_fop_attr_thrd_key(&fop_attr); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); + + ret = syncop_writev(subvol, fd, &iov, 1, offset, iobref, flags, &preiatt, + &postiatt, fop_attr, NULL); + DECODE_SYNCOP_ERR(ret); + + if (ret >= 0) { + if (prestat) + glfs_iatt_to_stat(glfd->fs, &preiatt, prestat); + if (poststat) + glfs_iatt_to_stat(glfd->fs, &postiatt, poststat); + } + + if (ret <= 0) + goto out; + + glfd->offset = (offset + iov.iov_len); out: - if (iobuf) - iobuf_unref (iobuf); - if (iobref) - iobref_unref (iobref); - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); - if (fop_attr) - dict_unref (fop_attr); + if (iobuf) + iobuf_unref(iobuf); + if (iobref) + iobref_unref(iobref); + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); + if (fop_attr) + dict_unref(fop_attr); - glfs_subvol_done (glfd->fs, subvol); + glfs_subvol_done(glfd->fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } ssize_t -pub_glfs_pwritev (struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt, - off_t offset, int flags) +pub_glfs_pwritev(struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt, + off_t offset, int flags) { - return glfs_pwritev_common (glfd, iovec, iovcnt, offset, flags, - NULL, NULL); + return glfs_pwritev_common(glfd, iovec, iovcnt, offset, flags, NULL, NULL); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwritev, 3.4.0); - ssize_t -pub_glfs_write (struct glfs_fd *glfd, const void *buf, size_t count, int flags) +pub_glfs_write(struct glfs_fd *glfd, const void *buf, size_t count, int flags) { - struct iovec iov = {0, }; - ssize_t ret = 0; + struct iovec iov = { + 0, + }; + ssize_t ret = 0; - iov.iov_base = (void *) buf; - iov.iov_len = count; + iov.iov_base = (void *)buf; + iov.iov_len = count; - ret = pub_glfs_pwritev (glfd, &iov, 1, glfd->offset, flags); + ret = pub_glfs_pwritev(glfd, &iov, 1, glfd->offset, flags); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_write, 3.4.0); - ssize_t -pub_glfs_writev (struct glfs_fd *glfd, const struct iovec *iov, int count, - int flags) +pub_glfs_writev(struct glfs_fd *glfd, const struct iovec *iov, int count, + int flags) { - ssize_t ret = 0; + ssize_t ret = 0; - ret = pub_glfs_pwritev (glfd, iov, count, glfd->offset, flags); + ret = pub_glfs_pwritev(glfd, iov, count, glfd->offset, flags); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_writev, 3.4.0); - ssize_t -pub_glfs_pwrite34 (struct glfs_fd *glfd, const void *buf, size_t count, - off_t offset, int flags) +pub_glfs_pwrite34(struct glfs_fd *glfd, const void *buf, size_t count, + off_t offset, int flags) { - struct iovec iov = {0, }; - ssize_t ret = 0; + struct iovec iov = { + 0, + }; + ssize_t ret = 0; - iov.iov_base = (void *) buf; - iov.iov_len = count; + iov.iov_base = (void *)buf; + iov.iov_len = count; - ret = pub_glfs_pwritev (glfd, &iov, 1, offset, flags); + ret = pub_glfs_pwritev(glfd, &iov, 1, offset, flags); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC(glfs_pwrite34, glfs_pwrite, 3.4.0); ssize_t -pub_glfs_pwrite (struct glfs_fd *glfd, const void *buf, size_t count, - off_t offset, int flags, struct stat *prestat, - struct stat *poststat) +pub_glfs_pwrite(struct glfs_fd *glfd, const void *buf, size_t count, + off_t offset, int flags, struct stat *prestat, + struct stat *poststat) { - struct iovec iov = {0, }; - ssize_t ret = 0; + struct iovec iov = { + 0, + }; + ssize_t ret = 0; - iov.iov_base = (void *) buf; - iov.iov_len = count; + iov.iov_base = (void *)buf; + iov.iov_len = count; - ret = glfs_pwritev_common (glfd, &iov, 1, offset, flags, - prestat, poststat); + ret = glfs_pwritev_common(glfd, &iov, 1, offset, flags, prestat, poststat); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwrite, future); -extern glfs_t *pub_glfs_from_glfd (glfs_fd_t *); - +extern glfs_t * +pub_glfs_from_glfd(glfs_fd_t *); static int -glfs_pwritev_async_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) +glfs_pwritev_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - glfs_io_async_cbk (op_ret, op_errno, frame, cookie, NULL, 0, - prebuf, postbuf); + glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, prebuf, + postbuf); - return 0; + return 0; } static int -glfs_pwritev_async_common (struct glfs_fd *glfd, const struct iovec *iovec, - int count, off_t offset, int flags, - gf_boolean_t oldcb, glfs_io_cbk fn, void *data) +glfs_pwritev_async_common(struct glfs_fd *glfd, const struct iovec *iovec, + int count, off_t offset, int flags, + gf_boolean_t oldcb, glfs_io_cbk fn, void *data) { - struct glfs_io *gio = NULL; - int ret = -1; - call_frame_t *frame = NULL; - xlator_t *subvol = NULL; - fd_t *fd = NULL; - struct iobref *iobref = NULL; - struct iobuf *iobuf = NULL; - dict_t *fop_attr = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - /* Need to take explicit ref so that the fd - * is not destroyed before the fop is complete - */ - GF_REF_GET (glfd); - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - errno = EBADFD; - goto out; - } - - gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t); - if (!gio) { - errno = ENOMEM; - goto out; - } - - gio->op = GF_FOP_WRITE; - gio->glfd = glfd; - gio->offset = offset; - gio->flags = flags; - gio->oldcb = oldcb; - gio->fn = fn; - gio->data = data; - gio->count = 1; - gio->iov = GF_CALLOC (gio->count, sizeof (*(gio->iov)), - gf_common_mt_iovec); - if (!gio->iov) { - errno = ENOMEM; - goto out; - } - - ret = iobuf_copy (subvol->ctx->iobuf_pool, iovec, count, &iobref, - &iobuf, gio->iov); - if (ret) - goto out; - - frame = syncop_create_frame (THIS); - if (!frame) { - errno = ENOMEM; - ret = -1; - goto out; - } - - frame->local = gio; - - ret = get_fop_attr_thrd_key (&fop_attr); - if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); - - STACK_WIND_COOKIE (frame, glfs_pwritev_async_cbk, subvol, subvol, - subvol->fops->writev, fd, gio->iov, - gio->count, offset, flags, iobref, fop_attr); - - ret = 0; + struct glfs_io *gio = NULL; + int ret = -1; + call_frame_t *frame = NULL; + xlator_t *subvol = NULL; + fd_t *fd = NULL; + struct iobref *iobref = NULL; + struct iobuf *iobuf = NULL; + dict_t *fop_attr = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + /* Need to take explicit ref so that the fd + * is not destroyed before the fop is complete + */ + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + errno = EBADFD; + goto out; + } + + gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t); + if (!gio) { + errno = ENOMEM; + goto out; + } + + gio->op = GF_FOP_WRITE; + gio->glfd = glfd; + gio->offset = offset; + gio->flags = flags; + gio->oldcb = oldcb; + gio->fn = fn; + gio->data = data; + gio->count = 1; + gio->iov = GF_CALLOC(gio->count, sizeof(*(gio->iov)), gf_common_mt_iovec); + if (!gio->iov) { + errno = ENOMEM; + goto out; + } + + ret = iobuf_copy(subvol->ctx->iobuf_pool, iovec, count, &iobref, &iobuf, + gio->iov); + if (ret) + goto out; + + frame = syncop_create_frame(THIS); + if (!frame) { + errno = ENOMEM; + ret = -1; + goto out; + } + + frame->local = gio; + + ret = get_fop_attr_thrd_key(&fop_attr); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); + + STACK_WIND_COOKIE(frame, glfs_pwritev_async_cbk, subvol, subvol, + subvol->fops->writev, fd, gio->iov, gio->count, offset, + flags, iobref, fop_attr); + + ret = 0; out: - if (ret) { - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); - GF_FREE (gio); - /* - * If there is any error condition check after the frame - * creation, we have to destroy the frame root. - */ - glfs_subvol_done (glfd->fs, subvol); - } - if (fop_attr) - dict_unref (fop_attr); + if (ret) { + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); + GF_FREE(gio); + /* + * If there is any error condition check after the frame + * creation, we have to destroy the frame root. + */ + glfs_subvol_done(glfd->fs, subvol); + } + if (fop_attr) + dict_unref(fop_attr); - if (iobuf) - iobuf_unref (iobuf); - if (iobref) - iobref_unref (iobref); + if (iobuf) + iobuf_unref(iobuf); + if (iobref) + iobref_unref(iobref); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } int -pub_glfs_pwritev_async34 (struct glfs_fd *glfd, const struct iovec *iovec, - int count, off_t offset, int flags, glfs_io_cbk34 fn, - void *data) +pub_glfs_pwritev_async34(struct glfs_fd *glfd, const struct iovec *iovec, + int count, off_t offset, int flags, glfs_io_cbk34 fn, + void *data) { - return glfs_pwritev_async_common (glfd, iovec, count, offset, flags, - _gf_true, (void *)fn, data); + return glfs_pwritev_async_common(glfd, iovec, count, offset, flags, + _gf_true, (void *)fn, data); } GFAPI_SYMVER_PUBLIC(glfs_pwritev_async34, glfs_pwritev_async, 3.4.0); - int -pub_glfs_pwritev_async (struct glfs_fd *glfd, const struct iovec *iovec, - int count, off_t offset, int flags, glfs_io_cbk fn, - void *data) +pub_glfs_pwritev_async(struct glfs_fd *glfd, const struct iovec *iovec, + int count, off_t offset, int flags, glfs_io_cbk fn, + void *data) { - return glfs_pwritev_async_common (glfd, iovec, count, offset, flags, - _gf_false, fn, data); + return glfs_pwritev_async_common(glfd, iovec, count, offset, flags, + _gf_false, fn, data); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwritev_async, future); - int -pub_glfs_write_async34 (struct glfs_fd *glfd, const void *buf, size_t count, - int flags, glfs_io_cbk34 fn, void *data) +pub_glfs_write_async34(struct glfs_fd *glfd, const void *buf, size_t count, + int flags, glfs_io_cbk34 fn, void *data) { - struct iovec iov = {0, }; - ssize_t ret = 0; + struct iovec iov = { + 0, + }; + ssize_t ret = 0; - iov.iov_base = (void *) buf; - iov.iov_len = count; + iov.iov_base = (void *)buf; + iov.iov_len = count; - ret = glfs_pwritev_async_common (glfd, &iov, 1, glfd->offset, flags, - _gf_true, (void *)fn, data); + ret = glfs_pwritev_async_common(glfd, &iov, 1, glfd->offset, flags, + _gf_true, (void *)fn, data); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC(glfs_write_async34, glfs_write_async, 3.4.0); - int -pub_glfs_write_async (struct glfs_fd *glfd, const void *buf, size_t count, - int flags, glfs_io_cbk fn, void *data) +pub_glfs_write_async(struct glfs_fd *glfd, const void *buf, size_t count, + int flags, glfs_io_cbk fn, void *data) { - struct iovec iov = {0, }; - ssize_t ret = 0; + struct iovec iov = { + 0, + }; + ssize_t ret = 0; - iov.iov_base = (void *) buf; - iov.iov_len = count; + iov.iov_base = (void *)buf; + iov.iov_len = count; - ret = glfs_pwritev_async_common (glfd, &iov, 1, glfd->offset, flags, - _gf_false, fn, data); + ret = glfs_pwritev_async_common(glfd, &iov, 1, glfd->offset, flags, + _gf_false, fn, data); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_write_async, future); - int -pub_glfs_pwrite_async34 (struct glfs_fd *glfd, const void *buf, int count, - off_t offset, int flags, glfs_io_cbk34 fn, void *data) +pub_glfs_pwrite_async34(struct glfs_fd *glfd, const void *buf, int count, + off_t offset, int flags, glfs_io_cbk34 fn, void *data) { - struct iovec iov = {0, }; - ssize_t ret = 0; + struct iovec iov = { + 0, + }; + ssize_t ret = 0; - iov.iov_base = (void *) buf; - iov.iov_len = count; + iov.iov_base = (void *)buf; + iov.iov_len = count; - ret = glfs_pwritev_async_common (glfd, &iov, 1, offset, flags, - _gf_true, (void *)fn, data); + ret = glfs_pwritev_async_common(glfd, &iov, 1, offset, flags, _gf_true, + (void *)fn, data); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC(glfs_pwrite_async34, glfs_pwrite_async, 3.4.0); - int -pub_glfs_pwrite_async (struct glfs_fd *glfd, const void *buf, int count, - off_t offset, int flags, glfs_io_cbk fn, void *data) +pub_glfs_pwrite_async(struct glfs_fd *glfd, const void *buf, int count, + off_t offset, int flags, glfs_io_cbk fn, void *data) { - struct iovec iov = {0, }; - ssize_t ret = 0; + struct iovec iov = { + 0, + }; + ssize_t ret = 0; - iov.iov_base = (void *) buf; - iov.iov_len = count; + iov.iov_base = (void *)buf; + iov.iov_len = count; - ret = glfs_pwritev_async_common (glfd, &iov, 1, offset, flags, - _gf_false, fn, data); + ret = glfs_pwritev_async_common(glfd, &iov, 1, offset, flags, _gf_false, fn, + data); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwrite_async, future); - int -pub_glfs_writev_async34 (struct glfs_fd *glfd, const struct iovec *iov, - int count, int flags, glfs_io_cbk34 fn, void *data) +pub_glfs_writev_async34(struct glfs_fd *glfd, const struct iovec *iov, + int count, int flags, glfs_io_cbk34 fn, void *data) { - ssize_t ret = 0; + ssize_t ret = 0; - ret = glfs_pwritev_async_common (glfd, iov, count, glfd->offset, flags, - _gf_true, (void *)fn, data); - return ret; + ret = glfs_pwritev_async_common(glfd, iov, count, glfd->offset, flags, + _gf_true, (void *)fn, data); + return ret; } GFAPI_SYMVER_PUBLIC(glfs_writev_async34, glfs_writev_async, 3.4.0); - int -pub_glfs_writev_async (struct glfs_fd *glfd, const struct iovec *iov, int count, - int flags, glfs_io_cbk fn, void *data) +pub_glfs_writev_async(struct glfs_fd *glfd, const struct iovec *iov, int count, + int flags, glfs_io_cbk fn, void *data) { - ssize_t ret = 0; + ssize_t ret = 0; - ret = glfs_pwritev_async_common (glfd, iov, count, glfd->offset, flags, - _gf_false, fn, data); - return ret; + ret = glfs_pwritev_async_common(glfd, iov, count, glfd->offset, flags, + _gf_false, fn, data); + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_writev_async, future); - static int -glfs_fsync_common (struct glfs_fd *glfd, struct stat *prestat, - struct stat *poststat) -{ - int ret = -1; - xlator_t *subvol = NULL; - fd_t *fd = NULL; - struct iatt preiatt = {0, }, postiatt = {0, }; - dict_t *fop_attr = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - GF_REF_GET (glfd); - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } - - ret = get_fop_attr_thrd_key (&fop_attr); - if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); - - ret = syncop_fsync (subvol, fd, 0, &preiatt, &postiatt, fop_attr, NULL); - DECODE_SYNCOP_ERR (ret); - - if (ret >= 0) { - if (prestat) - glfs_iatt_to_stat (glfd->fs, &preiatt, prestat); - if (poststat) - glfs_iatt_to_stat (glfd->fs, &postiatt, poststat); - } +glfs_fsync_common(struct glfs_fd *glfd, struct stat *prestat, + struct stat *poststat) +{ + int ret = -1; + xlator_t *subvol = NULL; + fd_t *fd = NULL; + struct iatt preiatt = + { + 0, + }, + postiatt = { + 0, + }; + dict_t *fop_attr = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + ret = get_fop_attr_thrd_key(&fop_attr); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); + + ret = syncop_fsync(subvol, fd, 0, &preiatt, &postiatt, fop_attr, NULL); + DECODE_SYNCOP_ERR(ret); + + if (ret >= 0) { + if (prestat) + glfs_iatt_to_stat(glfd->fs, &preiatt, prestat); + if (poststat) + glfs_iatt_to_stat(glfd->fs, &postiatt, poststat); + } out: - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); - if (fop_attr) - dict_unref (fop_attr); + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); + if (fop_attr) + dict_unref(fop_attr); - glfs_subvol_done (glfd->fs, subvol); + glfs_subvol_done(glfd->fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } int -pub_glfs_fsync34 (struct glfs_fd *glfd) +pub_glfs_fsync34(struct glfs_fd *glfd) { - return glfs_fsync_common (glfd, NULL, NULL); + return glfs_fsync_common(glfd, NULL, NULL); } GFAPI_SYMVER_PUBLIC(glfs_fsync34, glfs_fsync, 3.4.0); - int -pub_glfs_fsync (struct glfs_fd *glfd, struct stat *prestat, - struct stat *poststat) +pub_glfs_fsync(struct glfs_fd *glfd, struct stat *prestat, + struct stat *poststat) { - return glfs_fsync_common (glfd, prestat, poststat); + return glfs_fsync_common(glfd, prestat, poststat); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsync, future); - static int -glfs_fsync_async_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, - int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) +glfs_fsync_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - glfs_io_async_cbk (op_ret, op_errno, frame, cookie, NULL, 0, - prebuf, postbuf); + glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, prebuf, + postbuf); - return 0; + return 0; } static int -glfs_fsync_async_common (struct glfs_fd *glfd, gf_boolean_t oldcb, - glfs_io_cbk fn, void *data, int dataonly) -{ - struct glfs_io *gio = NULL; - int ret = 0; - call_frame_t *frame = NULL; - xlator_t *subvol = NULL; - fd_t *fd = NULL; +glfs_fsync_async_common(struct glfs_fd *glfd, gf_boolean_t oldcb, + glfs_io_cbk fn, void *data, int dataonly) +{ + struct glfs_io *gio = NULL; + int ret = 0; + call_frame_t *frame = NULL; + xlator_t *subvol = NULL; + fd_t *fd = NULL; + + /* Need to take explicit ref so that the fd + * is not destroyed before the fop is complete + */ + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + frame = syncop_create_frame(THIS); + if (!frame) { + ret = -1; + errno = ENOMEM; + goto out; + } + + gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t); + if (!gio) { + errno = ENOMEM; + ret = -1; + goto out; + } + + gio->op = GF_FOP_FSYNC; + gio->glfd = glfd; + gio->flags = dataonly; + gio->oldcb = oldcb; + gio->fn = fn; + gio->data = data; + + frame->local = gio; + + STACK_WIND_COOKIE(frame, glfs_fsync_async_cbk, subvol, subvol, + subvol->fops->fsync, fd, dataonly, NULL); - /* Need to take explicit ref so that the fd - * is not destroyed before the fop is complete - */ - GF_REF_GET (glfd); +out: + if (ret) { + if (fd) + fd_unref(fd); + GF_REF_PUT(glfd); + GF_FREE(gio); + if (frame) + STACK_DESTROY(frame->root); + glfs_subvol_done(glfd->fs, subvol); + } - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } + return ret; +} - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } +int +pub_glfs_fsync_async34(struct glfs_fd *glfd, glfs_io_cbk34 fn, void *data) +{ + int ret = -1; - frame = syncop_create_frame (THIS); - if (!frame) { - ret = -1; - errno = ENOMEM; - goto out; - } + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); - gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t); - if (!gio) { - errno = ENOMEM; - ret = -1; - goto out; - } + ret = glfs_fsync_async_common(glfd, _gf_true, (void *)fn, data, 0); - gio->op = GF_FOP_FSYNC; - gio->glfd = glfd; - gio->flags = dataonly; - gio->oldcb = oldcb; - gio->fn = fn; - gio->data = data; + __GLFS_EXIT_FS; - frame->local = gio; - - STACK_WIND_COOKIE (frame, glfs_fsync_async_cbk, subvol, subvol, - subvol->fops->fsync, fd, dataonly, NULL); - -out: - if (ret) { - if (fd) - fd_unref (fd); - GF_REF_PUT (glfd); - GF_FREE (gio); - if (frame) - STACK_DESTROY (frame->root); - glfs_subvol_done (glfd->fs, subvol); - } - - return ret; -} - - -int -pub_glfs_fsync_async34 (struct glfs_fd *glfd, glfs_io_cbk34 fn, void *data) -{ - int ret = -1; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - ret = glfs_fsync_async_common (glfd, _gf_true, (void *)fn, data, 0); - - __GLFS_EXIT_FS; - -invalid_fs: - return ret; -} - -GFAPI_SYMVER_PUBLIC(glfs_fsync_async34, glfs_fsync_async, 3.4.0); +invalid_fs: + return ret; +} +GFAPI_SYMVER_PUBLIC(glfs_fsync_async34, glfs_fsync_async, 3.4.0); int -pub_glfs_fsync_async (struct glfs_fd *glfd, glfs_io_cbk fn, void *data) +pub_glfs_fsync_async(struct glfs_fd *glfd, glfs_io_cbk fn, void *data) { - int ret = -1; + int ret = -1; - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); - ret = glfs_fsync_async_common (glfd, _gf_false, fn, data, 0); + ret = glfs_fsync_async_common(glfd, _gf_false, fn, data, 0); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsync_async, future); - static int -glfs_fdatasync_common (struct glfs_fd *glfd, struct stat *prestat, - struct stat *poststat) -{ - int ret = -1; - xlator_t *subvol = NULL; - fd_t *fd = NULL; - struct iatt preiatt = {0, }, postiatt = {0, }; - dict_t *fop_attr = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - GF_REF_GET (glfd); - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } - - ret = get_fop_attr_thrd_key (&fop_attr); - if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); - - ret = syncop_fsync (subvol, fd, 1, &preiatt, &postiatt, fop_attr, NULL); - DECODE_SYNCOP_ERR (ret); - - if (ret >= 0) { - if (prestat) - glfs_iatt_to_stat (glfd->fs, &preiatt, prestat); - if (poststat) - glfs_iatt_to_stat (glfd->fs, &postiatt, poststat); - } +glfs_fdatasync_common(struct glfs_fd *glfd, struct stat *prestat, + struct stat *poststat) +{ + int ret = -1; + xlator_t *subvol = NULL; + fd_t *fd = NULL; + struct iatt preiatt = + { + 0, + }, + postiatt = { + 0, + }; + dict_t *fop_attr = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + ret = get_fop_attr_thrd_key(&fop_attr); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); + + ret = syncop_fsync(subvol, fd, 1, &preiatt, &postiatt, fop_attr, NULL); + DECODE_SYNCOP_ERR(ret); + + if (ret >= 0) { + if (prestat) + glfs_iatt_to_stat(glfd->fs, &preiatt, prestat); + if (poststat) + glfs_iatt_to_stat(glfd->fs, &postiatt, poststat); + } out: - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); - if (fop_attr) - dict_unref (fop_attr); + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); + if (fop_attr) + dict_unref(fop_attr); - glfs_subvol_done (glfd->fs, subvol); + glfs_subvol_done(glfd->fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } int -pub_glfs_fdatasync34 (struct glfs_fd *glfd) +pub_glfs_fdatasync34(struct glfs_fd *glfd) { - return glfs_fdatasync_common (glfd, NULL, NULL); + return glfs_fdatasync_common(glfd, NULL, NULL); } GFAPI_SYMVER_PUBLIC(glfs_fdatasync34, glfs_fdatasync, 3.4.0); - int -pub_glfs_fdatasync (struct glfs_fd *glfd, struct stat *prestat, - struct stat *poststat) +pub_glfs_fdatasync(struct glfs_fd *glfd, struct stat *prestat, + struct stat *poststat) { - return glfs_fdatasync_common (glfd, prestat, poststat); + return glfs_fdatasync_common(glfd, prestat, poststat); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fdatasync, future); - int -pub_glfs_fdatasync_async34 (struct glfs_fd *glfd, glfs_io_cbk34 fn, void *data) +pub_glfs_fdatasync_async34(struct glfs_fd *glfd, glfs_io_cbk34 fn, void *data) { - int ret = -1; + int ret = -1; - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); - ret = glfs_fsync_async_common (glfd, _gf_true, (void *)fn, data, 1); + ret = glfs_fsync_async_common(glfd, _gf_true, (void *)fn, data, 1); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC(glfs_fdatasync_async34, glfs_fdatasync_async, 3.4.0); - int -pub_glfs_fdatasync_async (struct glfs_fd *glfd, glfs_io_cbk fn, void *data) +pub_glfs_fdatasync_async(struct glfs_fd *glfd, glfs_io_cbk fn, void *data) { - int ret = -1; + int ret = -1; - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); - ret = glfs_fsync_async_common (glfd, _gf_false, fn, data, 1); + ret = glfs_fsync_async_common(glfd, _gf_false, fn, data, 1); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fdatasync_async, future); - static int -glfs_ftruncate_common (struct glfs_fd *glfd, off_t offset, - struct stat *prestat, struct stat *poststat) -{ - int ret = -1; - xlator_t *subvol = NULL; - fd_t *fd = NULL; - struct iatt preiatt = {0, }, postiatt = {0, }; - dict_t *fop_attr = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - GF_REF_GET (glfd); - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } - - ret = get_fop_attr_thrd_key (&fop_attr); - if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); - - ret = syncop_ftruncate (subvol, fd, offset, &preiatt, &postiatt, - fop_attr, NULL); - DECODE_SYNCOP_ERR (ret); - - if (ret >= 0) { - if (prestat) - glfs_iatt_to_stat (glfd->fs, &preiatt, prestat); - if (poststat) - glfs_iatt_to_stat (glfd->fs, &postiatt, poststat); - } +glfs_ftruncate_common(struct glfs_fd *glfd, off_t offset, struct stat *prestat, + struct stat *poststat) +{ + int ret = -1; + xlator_t *subvol = NULL; + fd_t *fd = NULL; + struct iatt preiatt = + { + 0, + }, + postiatt = { + 0, + }; + dict_t *fop_attr = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + ret = get_fop_attr_thrd_key(&fop_attr); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); + + ret = syncop_ftruncate(subvol, fd, offset, &preiatt, &postiatt, fop_attr, + NULL); + DECODE_SYNCOP_ERR(ret); + + if (ret >= 0) { + if (prestat) + glfs_iatt_to_stat(glfd->fs, &preiatt, prestat); + if (poststat) + glfs_iatt_to_stat(glfd->fs, &postiatt, poststat); + } out: - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); - if (fop_attr) - dict_unref (fop_attr); + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); + if (fop_attr) + dict_unref(fop_attr); - glfs_subvol_done (glfd->fs, subvol); + glfs_subvol_done(glfd->fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } int -pub_glfs_ftruncate34 (struct glfs_fd *glfd, off_t offset) +pub_glfs_ftruncate34(struct glfs_fd *glfd, off_t offset) { - return glfs_ftruncate_common (glfd, offset, NULL, NULL); + return glfs_ftruncate_common(glfd, offset, NULL, NULL); } GFAPI_SYMVER_PUBLIC(glfs_ftruncate34, glfs_ftruncate, 3.4.0); - int -pub_glfs_ftruncate (struct glfs_fd *glfd, off_t offset, struct stat *prestat, - struct stat *poststat) +pub_glfs_ftruncate(struct glfs_fd *glfd, off_t offset, struct stat *prestat, + struct stat *poststat) { - return glfs_ftruncate_common (glfd, offset, prestat, poststat); + return glfs_ftruncate_common(glfd, offset, prestat, poststat); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_ftruncate, future); - int -pub_glfs_truncate (struct glfs *fs, const char *path, off_t length) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +pub_glfs_truncate(struct glfs *fs, const char *path, off_t length) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval); + ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret) - goto out; + if (ret) + goto out; - ret = syncop_truncate (subvol, &loc, length, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + ret = syncop_truncate(subvol, &loc, length, NULL, NULL); + DECODE_SYNCOP_ERR(ret); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); out: - loc_wipe (&loc); + loc_wipe(&loc); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_truncate, 3.7.15); - static int -glfs_ftruncate_async_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf, - dict_t *xdata) +glfs_ftruncate_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - glfs_io_async_cbk (op_ret, op_errno, frame, cookie, NULL, 0, - prebuf, postbuf); + glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, prebuf, + postbuf); - return 0; + return 0; } static int -glfs_ftruncate_async_common (struct glfs_fd *glfd, off_t offset, - gf_boolean_t oldcb, glfs_io_cbk fn, void *data) +glfs_ftruncate_async_common(struct glfs_fd *glfd, off_t offset, + gf_boolean_t oldcb, glfs_io_cbk fn, void *data) { - struct glfs_io *gio = NULL; - int ret = -1; - call_frame_t *frame = NULL; - xlator_t *subvol = NULL; - fd_t *fd = NULL; - dict_t *fop_attr = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - /* Need to take explicit ref so that the fd - * is not destroyed before the fop is complete - */ - GF_REF_GET (glfd); - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - errno = EBADFD; - goto out; - } - - frame = syncop_create_frame (THIS); - if (!frame) { - errno = ENOMEM; - goto out; - } - - gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t); - if (!gio) { - errno = ENOMEM; - goto out; - } - - gio->op = GF_FOP_FTRUNCATE; - gio->glfd = glfd; - gio->offset = offset; - gio->oldcb = oldcb; - gio->fn = fn; - gio->data = data; - - frame->local = gio; - - ret = get_fop_attr_thrd_key (&fop_attr); - if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); - - STACK_WIND_COOKIE (frame, glfs_ftruncate_async_cbk, subvol, subvol, - subvol->fops->ftruncate, fd, offset, fop_attr); - - ret = 0; + struct glfs_io *gio = NULL; + int ret = -1; + call_frame_t *frame = NULL; + xlator_t *subvol = NULL; + fd_t *fd = NULL; + dict_t *fop_attr = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + /* Need to take explicit ref so that the fd + * is not destroyed before the fop is complete + */ + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + errno = EBADFD; + goto out; + } + + frame = syncop_create_frame(THIS); + if (!frame) { + errno = ENOMEM; + goto out; + } + + gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t); + if (!gio) { + errno = ENOMEM; + goto out; + } + + gio->op = GF_FOP_FTRUNCATE; + gio->glfd = glfd; + gio->offset = offset; + gio->oldcb = oldcb; + gio->fn = fn; + gio->data = data; + + frame->local = gio; + + ret = get_fop_attr_thrd_key(&fop_attr); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); + + STACK_WIND_COOKIE(frame, glfs_ftruncate_async_cbk, subvol, subvol, + subvol->fops->ftruncate, fd, offset, fop_attr); + + ret = 0; out: - if (ret) { - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); - GF_FREE (gio); - if (frame) - STACK_DESTROY (frame->root); - glfs_subvol_done (glfd->fs, subvol); - } - if (fop_attr) - dict_unref (fop_attr); + if (ret) { + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); + GF_FREE(gio); + if (frame) + STACK_DESTROY(frame->root); + glfs_subvol_done(glfd->fs, subvol); + } + if (fop_attr) + dict_unref(fop_attr); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } int -pub_glfs_ftruncate_async34 (struct glfs_fd *glfd, off_t offset, - glfs_io_cbk34 fn, void *data) +pub_glfs_ftruncate_async34(struct glfs_fd *glfd, off_t offset, glfs_io_cbk34 fn, + void *data) { - return glfs_ftruncate_async_common (glfd, offset, _gf_true, - (void *)fn, data); + return glfs_ftruncate_async_common(glfd, offset, _gf_true, (void *)fn, + data); } GFAPI_SYMVER_PUBLIC(glfs_ftruncate_async34, glfs_ftruncate_async, 3.4.0); - int -pub_glfs_ftruncate_async (struct glfs_fd *glfd, off_t offset, - glfs_io_cbk fn, void *data) +pub_glfs_ftruncate_async(struct glfs_fd *glfd, off_t offset, glfs_io_cbk fn, + void *data) { - return glfs_ftruncate_async_common (glfd, offset, _gf_false, fn, data); + return glfs_ftruncate_async_common(glfd, offset, _gf_false, fn, data); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_ftruncate_async, future); - int -pub_glfs_access (struct glfs *fs, const char *path, int mode) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +pub_glfs_access(struct glfs *fs, const char *path, int mode) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval); + ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret) - goto out; + if (ret) + goto out; - ret = syncop_access (subvol, &loc, mode, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + ret = syncop_access(subvol, &loc, mode, NULL, NULL); + DECODE_SYNCOP_ERR(ret); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); out: - loc_wipe (&loc); + loc_wipe(&loc); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_access, 3.4.0); - int -pub_glfs_symlink (struct glfs *fs, const char *data, const char *path) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - uuid_t gfid; - dict_t *xattr_req = NULL; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - xattr_req = dict_new (); - if (!xattr_req) { - ret = -1; - errno = ENOMEM; - goto out; - } - - gf_uuid_generate (gfid); - ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true); - if (ret) { - ret = -1; - errno = ENOMEM; - goto out; - } +pub_glfs_symlink(struct glfs *fs, const char *data, const char *path) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + uuid_t gfid; + dict_t *xattr_req = NULL; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + xattr_req = dict_new(); + if (!xattr_req) { + ret = -1; + errno = ENOMEM; + goto out; + } + + gf_uuid_generate(gfid); + ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true); + if (ret) { + ret = -1; + errno = ENOMEM; + goto out; + } retry: - ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval); + ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (loc.inode) { - errno = EEXIST; - ret = -1; - goto out; - } + if (loc.inode) { + errno = EEXIST; + ret = -1; + goto out; + } - if (ret == -1 && errno != ENOENT) - /* Any other type of error is fatal */ - goto out; + if (ret == -1 && errno != ENOENT) + /* Any other type of error is fatal */ + goto out; - if (ret == -1 && errno == ENOENT && !loc.parent) - /* The parent directory or an ancestor even - higher does not exist - */ - goto out; + if (ret == -1 && errno == ENOENT && !loc.parent) + /* The parent directory or an ancestor even + higher does not exist + */ + goto out; - /* ret == -1 && errno == ENOENT */ - loc.inode = inode_new (loc.parent->table); - if (!loc.inode) { - ret = -1; - errno = ENOMEM; - goto out; - } + /* ret == -1 && errno == ENOENT */ + loc.inode = inode_new(loc.parent->table); + if (!loc.inode) { + ret = -1; + errno = ENOMEM; + goto out; + } - ret = syncop_symlink (subvol, &loc, data, &iatt, xattr_req, NULL); - DECODE_SYNCOP_ERR (ret); + ret = syncop_symlink(subvol, &loc, data, &iatt, xattr_req, NULL); + DECODE_SYNCOP_ERR(ret); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret == 0) - ret = glfs_loc_link (&loc, &iatt); + if (ret == 0) + ret = glfs_loc_link(&loc, &iatt); out: - loc_wipe (&loc); + loc_wipe(&loc); - if (xattr_req) - dict_unref (xattr_req); + if (xattr_req) + dict_unref(xattr_req); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_symlink, 3.4.0); - int -pub_glfs_readlink (struct glfs *fs, const char *path, char *buf, size_t bufsiz) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - int reval = 0; - char *linkval = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +pub_glfs_readlink(struct glfs *fs, const char *path, char *buf, size_t bufsiz) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + int reval = 0; + char *linkval = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval); + ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret) - goto out; + if (ret) + goto out; - if (iatt.ia_type != IA_IFLNK) { - ret = -1; - errno = EINVAL; - goto out; - } + if (iatt.ia_type != IA_IFLNK) { + ret = -1; + errno = EINVAL; + goto out; + } - ret = syncop_readlink (subvol, &loc, &linkval, bufsiz, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - if (ret > 0) { - memcpy (buf, linkval, ret); - GF_FREE (linkval); - } + ret = syncop_readlink(subvol, &loc, &linkval, bufsiz, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + if (ret > 0) { + memcpy(buf, linkval, ret); + GF_FREE(linkval); + } - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); out: - loc_wipe (&loc); + loc_wipe(&loc); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readlink, 3.4.0); - int -pub_glfs_mknod (struct glfs *fs, const char *path, mode_t mode, dev_t dev) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - uuid_t gfid; - dict_t *xattr_req = NULL; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - xattr_req = dict_new (); - if (!xattr_req) { - ret = -1; - errno = ENOMEM; - goto out; - } - - gf_uuid_generate (gfid); - ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true); - if (ret) { - ret = -1; - errno = ENOMEM; - goto out; - } +pub_glfs_mknod(struct glfs *fs, const char *path, mode_t mode, dev_t dev) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + uuid_t gfid; + dict_t *xattr_req = NULL; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + xattr_req = dict_new(); + if (!xattr_req) { + ret = -1; + errno = ENOMEM; + goto out; + } + + gf_uuid_generate(gfid); + ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true); + if (ret) { + ret = -1; + errno = ENOMEM; + goto out; + } retry: - ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval); + ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (loc.inode) { - errno = EEXIST; - ret = -1; - goto out; - } + if (loc.inode) { + errno = EEXIST; + ret = -1; + goto out; + } - if (ret == -1 && errno != ENOENT) - /* Any other type of error is fatal */ - goto out; + if (ret == -1 && errno != ENOENT) + /* Any other type of error is fatal */ + goto out; - if (ret == -1 && errno == ENOENT && !loc.parent) - /* The parent directory or an ancestor even - higher does not exist - */ - goto out; + if (ret == -1 && errno == ENOENT && !loc.parent) + /* The parent directory or an ancestor even + higher does not exist + */ + goto out; - /* ret == -1 && errno == ENOENT */ - loc.inode = inode_new (loc.parent->table); - if (!loc.inode) { - ret = -1; - errno = ENOMEM; - goto out; - } + /* ret == -1 && errno == ENOENT */ + loc.inode = inode_new(loc.parent->table); + if (!loc.inode) { + ret = -1; + errno = ENOMEM; + goto out; + } - ret = syncop_mknod (subvol, &loc, mode, dev, &iatt, xattr_req, NULL); - DECODE_SYNCOP_ERR (ret); + ret = syncop_mknod(subvol, &loc, mode, dev, &iatt, xattr_req, NULL); + DECODE_SYNCOP_ERR(ret); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret == 0) - ret = glfs_loc_link (&loc, &iatt); + if (ret == 0) + ret = glfs_loc_link(&loc, &iatt); out: - loc_wipe (&loc); + loc_wipe(&loc); - if (xattr_req) - dict_unref (xattr_req); + if (xattr_req) + dict_unref(xattr_req); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_mknod, 3.4.0); - int -pub_glfs_mkdir (struct glfs *fs, const char *path, mode_t mode) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - uuid_t gfid; - dict_t *xattr_req = NULL; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - xattr_req = dict_new (); - if (!xattr_req) { - ret = -1; - errno = ENOMEM; - goto out; - } - - gf_uuid_generate (gfid); - ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true); - if (ret) { - ret = -1; - errno = ENOMEM; - goto out; - } +pub_glfs_mkdir(struct glfs *fs, const char *path, mode_t mode) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + uuid_t gfid; + dict_t *xattr_req = NULL; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + xattr_req = dict_new(); + if (!xattr_req) { + ret = -1; + errno = ENOMEM; + goto out; + } + + gf_uuid_generate(gfid); + ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true); + if (ret) { + ret = -1; + errno = ENOMEM; + goto out; + } retry: - ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval); + ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (loc.inode) { - errno = EEXIST; - ret = -1; - goto out; - } + if (loc.inode) { + errno = EEXIST; + ret = -1; + goto out; + } - if (ret == -1 && errno != ENOENT) - /* Any other type of error is fatal */ - goto out; + if (ret == -1 && errno != ENOENT) + /* Any other type of error is fatal */ + goto out; - if (ret == -1 && errno == ENOENT && !loc.parent) - /* The parent directory or an ancestor even - higher does not exist - */ - goto out; + if (ret == -1 && errno == ENOENT && !loc.parent) + /* The parent directory or an ancestor even + higher does not exist + */ + goto out; - /* ret == -1 && errno == ENOENT */ - loc.inode = inode_new (loc.parent->table); - if (!loc.inode) { - ret = -1; - errno = ENOMEM; - goto out; - } + /* ret == -1 && errno == ENOENT */ + loc.inode = inode_new(loc.parent->table); + if (!loc.inode) { + ret = -1; + errno = ENOMEM; + goto out; + } - ret = syncop_mkdir (subvol, &loc, mode, &iatt, xattr_req, NULL); - DECODE_SYNCOP_ERR (ret); + ret = syncop_mkdir(subvol, &loc, mode, &iatt, xattr_req, NULL); + DECODE_SYNCOP_ERR(ret); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret == 0) - ret = glfs_loc_link (&loc, &iatt); + if (ret == 0) + ret = glfs_loc_link(&loc, &iatt); out: - loc_wipe (&loc); + loc_wipe(&loc); - if (xattr_req) - dict_unref (xattr_req); + if (xattr_req) + dict_unref(xattr_req); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_mkdir, 3.4.0); - int -pub_glfs_unlink (struct glfs *fs, const char *path) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +pub_glfs_unlink(struct glfs *fs, const char *path) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval); + ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret) - goto out; + if (ret) + goto out; - if (iatt.ia_type == IA_IFDIR) { - ret = -1; - errno = EISDIR; - goto out; - } + if (iatt.ia_type == IA_IFDIR) { + ret = -1; + errno = EISDIR; + goto out; + } - /* TODO: Add leaseid */ - ret = syncop_unlink (subvol, &loc, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + /* TODO: Add leaseid */ + ret = syncop_unlink(subvol, &loc, NULL, NULL); + DECODE_SYNCOP_ERR(ret); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret == 0) - ret = glfs_loc_unlink (&loc); + if (ret == 0) + ret = glfs_loc_unlink(&loc); out: - loc_wipe (&loc); + loc_wipe(&loc); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_unlink, 3.4.0); - int -pub_glfs_rmdir (struct glfs *fs, const char *path) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +pub_glfs_rmdir(struct glfs *fs, const char *path) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval); + ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret) - goto out; + if (ret) + goto out; - if (iatt.ia_type != IA_IFDIR) { - ret = -1; - errno = ENOTDIR; - goto out; - } + if (iatt.ia_type != IA_IFDIR) { + ret = -1; + errno = ENOTDIR; + goto out; + } - ret = syncop_rmdir (subvol, &loc, 0, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + ret = syncop_rmdir(subvol, &loc, 0, NULL, NULL); + DECODE_SYNCOP_ERR(ret); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret == 0) - ret = glfs_loc_unlink (&loc); + if (ret == 0) + ret = glfs_loc_unlink(&loc); out: - loc_wipe (&loc); + loc_wipe(&loc); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_rmdir, 3.4.0); - int -pub_glfs_rename (struct glfs *fs, const char *oldpath, const char *newpath) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t oldloc = {0, }; - loc_t newloc = {0, }; - struct iatt oldiatt = {0, }; - struct iatt newiatt = {0, }; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +pub_glfs_rename(struct glfs *fs, const char *oldpath, const char *newpath) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t oldloc = { + 0, + }; + loc_t newloc = { + 0, + }; + struct iatt oldiatt = { + 0, + }; + struct iatt newiatt = { + 0, + }; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - ret = glfs_lresolve (fs, subvol, oldpath, &oldloc, &oldiatt, reval); + ret = glfs_lresolve(fs, subvol, oldpath, &oldloc, &oldiatt, reval); - ESTALE_RETRY (ret, errno, reval, &oldloc, retry); + ESTALE_RETRY(ret, errno, reval, &oldloc, retry); - if (ret) - goto out; + if (ret) + goto out; retrynew: - ret = glfs_lresolve (fs, subvol, newpath, &newloc, &newiatt, reval); - - ESTALE_RETRY (ret, errno, reval, &newloc, retrynew); - - if (ret && errno != ENOENT && newloc.parent) - goto out; - - if (newiatt.ia_type != IA_INVAL) { - if ((oldiatt.ia_type == IA_IFDIR) != - (newiatt.ia_type == IA_IFDIR)) { - /* Either both old and new must be dirs, - * or both must be non-dirs. Else, fail. - */ - ret = -1; - errno = EISDIR; - goto out; - } + ret = glfs_lresolve(fs, subvol, newpath, &newloc, &newiatt, reval); + + ESTALE_RETRY(ret, errno, reval, &newloc, retrynew); + + if (ret && errno != ENOENT && newloc.parent) + goto out; + + if (newiatt.ia_type != IA_INVAL) { + if ((oldiatt.ia_type == IA_IFDIR) != (newiatt.ia_type == IA_IFDIR)) { + /* Either both old and new must be dirs, + * or both must be non-dirs. Else, fail. + */ + ret = -1; + errno = EISDIR; + goto out; + } + } + + /* TODO: - check if new or old is a prefix of the other, and fail EINVAL + * - Add leaseid */ + + ret = syncop_rename(subvol, &oldloc, &newloc, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + + if (ret == -1 && errno == ESTALE) { + if (reval < DEFAULT_REVAL_COUNT) { + reval++; + loc_wipe(&oldloc); + loc_wipe(&newloc); + goto retry; } + } + + if (ret == 0) { + inode_rename(oldloc.parent->table, oldloc.parent, oldloc.name, + newloc.parent, newloc.name, oldloc.inode, &oldiatt); - /* TODO: - check if new or old is a prefix of the other, and fail EINVAL - * - Add leaseid */ - - ret = syncop_rename (subvol, &oldloc, &newloc, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - - if (ret == -1 && errno == ESTALE) { - if (reval < DEFAULT_REVAL_COUNT) { - reval++; - loc_wipe (&oldloc); - loc_wipe (&newloc); - goto retry; - } - } - - if (ret == 0) { - inode_rename (oldloc.parent->table, oldloc.parent, oldloc.name, - newloc.parent, newloc.name, oldloc.inode, - &oldiatt); - - if (newloc.inode && !inode_has_dentry (newloc.inode)) - inode_forget (newloc.inode, 0); - } + if (newloc.inode && !inode_has_dentry(newloc.inode)) + inode_forget(newloc.inode, 0); + } out: - loc_wipe (&oldloc); - loc_wipe (&newloc); + loc_wipe(&oldloc); + loc_wipe(&newloc); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_rename, 3.4.0); - int -pub_glfs_link (struct glfs *fs, const char *oldpath, const char *newpath) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t oldloc = {0, }; - loc_t newloc = {0, }; - struct iatt oldiatt = {0, }; - struct iatt newiatt = {0, }; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +pub_glfs_link(struct glfs *fs, const char *oldpath, const char *newpath) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t oldloc = { + 0, + }; + loc_t newloc = { + 0, + }; + struct iatt oldiatt = { + 0, + }; + struct iatt newiatt = { + 0, + }; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - ret = glfs_lresolve (fs, subvol, oldpath, &oldloc, &oldiatt, reval); + ret = glfs_lresolve(fs, subvol, oldpath, &oldloc, &oldiatt, reval); - ESTALE_RETRY (ret, errno, reval, &oldloc, retry); + ESTALE_RETRY(ret, errno, reval, &oldloc, retry); - if (ret) - goto out; + if (ret) + goto out; retrynew: - ret = glfs_lresolve (fs, subvol, newpath, &newloc, &newiatt, reval); - - ESTALE_RETRY (ret, errno, reval, &newloc, retrynew); - - if (ret == 0) { - ret = -1; - errno = EEXIST; - goto out; - } - - if (oldiatt.ia_type == IA_IFDIR) { - ret = -1; - errno = EISDIR; - goto out; - } - - /* Filling the inode of the hard link to be same as that of the - original file - */ - if (newloc.inode) { - inode_unref (newloc.inode); - newloc.inode = NULL; - } - newloc.inode = inode_ref (oldloc.inode); - - ret = syncop_link (subvol, &oldloc, &newloc, &newiatt, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - - if (ret == -1 && errno == ESTALE) { - loc_wipe (&oldloc); - loc_wipe (&newloc); - if (reval--) - goto retry; - } - - if (ret == 0) - ret = glfs_loc_link (&newloc, &newiatt); + ret = glfs_lresolve(fs, subvol, newpath, &newloc, &newiatt, reval); + + ESTALE_RETRY(ret, errno, reval, &newloc, retrynew); + + if (ret == 0) { + ret = -1; + errno = EEXIST; + goto out; + } + + if (oldiatt.ia_type == IA_IFDIR) { + ret = -1; + errno = EISDIR; + goto out; + } + + /* Filling the inode of the hard link to be same as that of the + original file + */ + if (newloc.inode) { + inode_unref(newloc.inode); + newloc.inode = NULL; + } + newloc.inode = inode_ref(oldloc.inode); + + ret = syncop_link(subvol, &oldloc, &newloc, &newiatt, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + + if (ret == -1 && errno == ESTALE) { + loc_wipe(&oldloc); + loc_wipe(&newloc); + if (reval--) + goto retry; + } + + if (ret == 0) + ret = glfs_loc_link(&newloc, &newiatt); out: - loc_wipe (&oldloc); - loc_wipe (&newloc); + loc_wipe(&oldloc); + loc_wipe(&newloc); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_link, 3.4.0); - struct glfs_fd * -pub_glfs_opendir (struct glfs *fs, const char *path) -{ - int ret = -1; - struct glfs_fd *glfd = NULL; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - glfd = glfs_fd_new (fs); - if (!glfd) - goto out; - - INIT_LIST_HEAD (&glfd->entries); +pub_glfs_opendir(struct glfs *fs, const char *path) +{ + int ret = -1; + struct glfs_fd *glfd = NULL; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + glfd = glfs_fd_new(fs); + if (!glfd) + goto out; + + INIT_LIST_HEAD(&glfd->entries); retry: - ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval); - - ESTALE_RETRY (ret, errno, reval, &loc, retry); - - if (ret) - goto out; - - if (!IA_ISDIR (iatt.ia_type)) { - ret = -1; - errno = ENOTDIR; - goto out; - } - - if (glfd->fd) { - /* Retry. Safe to touch glfd->fd as we - still have not glfs_fd_bind() yet. - */ - fd_unref (glfd->fd); - glfd->fd = NULL; - } - - glfd->fd = fd_create (loc.inode, getpid()); - if (!glfd->fd) { - ret = -1; - errno = ENOMEM; - goto out; - } - - ret = syncop_opendir (subvol, &loc, glfd->fd, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval); + + ESTALE_RETRY(ret, errno, reval, &loc, retry); + + if (ret) + goto out; + + if (!IA_ISDIR(iatt.ia_type)) { + ret = -1; + errno = ENOTDIR; + goto out; + } + + if (glfd->fd) { + /* Retry. Safe to touch glfd->fd as we + still have not glfs_fd_bind() yet. + */ + fd_unref(glfd->fd); + glfd->fd = NULL; + } + + glfd->fd = fd_create(loc.inode, getpid()); + if (!glfd->fd) { + ret = -1; + errno = ENOMEM; + goto out; + } + + ret = syncop_opendir(subvol, &loc, glfd->fd, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + + ESTALE_RETRY(ret, errno, reval, &loc, retry); out: - loc_wipe (&loc); + loc_wipe(&loc); - if (ret && glfd) { - GF_REF_PUT (glfd); - glfd = NULL; - } else if (glfd) { - glfd_set_state_bind (glfd); - } + if (ret && glfd) { + GF_REF_PUT(glfd); + glfd = NULL; + } else if (glfd) { + glfd_set_state_bind(glfd); + } - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return glfd; + return glfd; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_opendir, 3.4.0); - int -pub_glfs_closedir (struct glfs_fd *glfd) +pub_glfs_closedir(struct glfs_fd *glfd) { - int ret = -1; + int ret = -1; - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); - gf_dirent_free (list_entry (&glfd->entries, gf_dirent_t, list)); + gf_dirent_free(list_entry(&glfd->entries, gf_dirent_t, list)); - glfs_mark_glfd_for_deletion (glfd); + glfs_mark_glfd_for_deletion(glfd); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; - ret = 0; + ret = 0; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_closedir, 3.4.0); - long -pub_glfs_telldir (struct glfs_fd *fd) +pub_glfs_telldir(struct glfs_fd *fd) { - return fd->offset; + return fd->offset; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_telldir, 3.4.0); - void -pub_glfs_seekdir (struct glfs_fd *fd, long offset) +pub_glfs_seekdir(struct glfs_fd *fd, long offset) { - gf_dirent_t *entry = NULL; - gf_dirent_t *tmp = NULL; + gf_dirent_t *entry = NULL; + gf_dirent_t *tmp = NULL; - if (fd->offset == offset) - return; + if (fd->offset == offset) + return; - fd->offset = offset; - fd->next = NULL; + fd->offset = offset; + fd->next = NULL; - list_for_each_entry_safe (entry, tmp, &fd->entries, list) { - if (entry->d_off != offset) - continue; + list_for_each_entry_safe(entry, tmp, &fd->entries, list) + { + if (entry->d_off != offset) + continue; - if (&tmp->list != &fd->entries) { - /* found! */ - fd->next = tmp; - return; - } - } - /* could not find entry at requested offset in the cache. - next readdir_r() will result in glfd_entry_refresh() - */ + if (&tmp->list != &fd->entries) { + /* found! */ + fd->next = tmp; + return; + } + } + /* could not find entry at requested offset in the cache. + next readdir_r() will result in glfd_entry_refresh() + */ } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_seekdir, 3.4.0); static int -glfs_discard_async_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, - int32_t op_errno, struct iatt *preop_stbuf, - struct iatt *postop_stbuf, dict_t *xdata) +glfs_discard_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, + struct iatt *preop_stbuf, struct iatt *postop_stbuf, + dict_t *xdata) { - glfs_io_async_cbk (op_ret, op_errno, frame, cookie, NULL, 0, - preop_stbuf, postop_stbuf); + glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, preop_stbuf, + postop_stbuf); - return 0; + return 0; } static int -glfs_discard_async_common (struct glfs_fd *glfd, off_t offset, size_t len, - gf_boolean_t oldcb, glfs_io_cbk fn, void *data) +glfs_discard_async_common(struct glfs_fd *glfd, off_t offset, size_t len, + gf_boolean_t oldcb, glfs_io_cbk fn, void *data) { - struct glfs_io *gio = NULL; - int ret = -1; - call_frame_t *frame = NULL; - xlator_t *subvol = NULL; - fd_t *fd = NULL; - dict_t *fop_attr = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - /* Need to take explicit ref so that the fd - * is not destroyed before the fop is complete - */ - GF_REF_GET (glfd); - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - errno = EBADFD; - goto out; - } - - frame = syncop_create_frame (THIS); - if (!frame) { - errno = ENOMEM; - goto out; - } - - gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t); - if (!gio) { - errno = ENOMEM; - goto out; - } - - gio->op = GF_FOP_DISCARD; - gio->glfd = glfd; - gio->offset = offset; - gio->count = len; - gio->oldcb = oldcb; - gio->fn = fn; - gio->data = data; - - frame->local = gio; - ret = get_fop_attr_thrd_key (&fop_attr); - if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); - - STACK_WIND_COOKIE (frame, glfs_discard_async_cbk, subvol, subvol, - subvol->fops->discard, fd, offset, len, fop_attr); - - ret = 0; + struct glfs_io *gio = NULL; + int ret = -1; + call_frame_t *frame = NULL; + xlator_t *subvol = NULL; + fd_t *fd = NULL; + dict_t *fop_attr = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + /* Need to take explicit ref so that the fd + * is not destroyed before the fop is complete + */ + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + errno = EBADFD; + goto out; + } + + frame = syncop_create_frame(THIS); + if (!frame) { + errno = ENOMEM; + goto out; + } + + gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t); + if (!gio) { + errno = ENOMEM; + goto out; + } + + gio->op = GF_FOP_DISCARD; + gio->glfd = glfd; + gio->offset = offset; + gio->count = len; + gio->oldcb = oldcb; + gio->fn = fn; + gio->data = data; + + frame->local = gio; + ret = get_fop_attr_thrd_key(&fop_attr); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); + + STACK_WIND_COOKIE(frame, glfs_discard_async_cbk, subvol, subvol, + subvol->fops->discard, fd, offset, len, fop_attr); + + ret = 0; out: - if (ret) { - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); - GF_FREE (gio); - if (frame) - STACK_DESTROY (frame->root); - glfs_subvol_done (glfd->fs, subvol); - } + if (ret) { + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); + GF_FREE(gio); + if (frame) + STACK_DESTROY(frame->root); + glfs_subvol_done(glfd->fs, subvol); + } - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } int -pub_glfs_discard_async35 (struct glfs_fd *glfd, off_t offset, size_t len, - glfs_io_cbk34 fn, void *data) +pub_glfs_discard_async35(struct glfs_fd *glfd, off_t offset, size_t len, + glfs_io_cbk34 fn, void *data) { - return glfs_discard_async_common (glfd, offset, len, _gf_true, - (void *)fn, data); + return glfs_discard_async_common(glfd, offset, len, _gf_true, (void *)fn, + data); } GFAPI_SYMVER_PUBLIC(glfs_discard_async35, glfs_discard_async, 3.5.0); - int -pub_glfs_discard_async (struct glfs_fd *glfd, off_t offset, size_t len, - glfs_io_cbk fn, void *data) +pub_glfs_discard_async(struct glfs_fd *glfd, off_t offset, size_t len, + glfs_io_cbk fn, void *data) { - return glfs_discard_async_common (glfd, offset, len, _gf_false, fn, - data); + return glfs_discard_async_common(glfd, offset, len, _gf_false, fn, data); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_discard_async, future); - static int -glfs_zerofill_async_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, - int32_t op_errno, struct iatt *preop_stbuf, - struct iatt *postop_stbuf, dict_t *xdata) +glfs_zerofill_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, + struct iatt *preop_stbuf, struct iatt *postop_stbuf, + dict_t *xdata) { - glfs_io_async_cbk (op_ret, op_errno, frame, cookie, NULL, 0, - preop_stbuf, postop_stbuf); + glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, preop_stbuf, + postop_stbuf); - return 0; + return 0; } - static int -glfs_zerofill_async_common (struct glfs_fd *glfd, off_t offset, off_t len, - gf_boolean_t oldcb, glfs_io_cbk fn, void *data) +glfs_zerofill_async_common(struct glfs_fd *glfd, off_t offset, off_t len, + gf_boolean_t oldcb, glfs_io_cbk fn, void *data) { - struct glfs_io *gio = NULL; - int ret = -1; - call_frame_t *frame = NULL; - xlator_t *subvol = NULL; - fd_t *fd = NULL; - dict_t *fop_attr = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - /* Need to take explicit ref so that the fd - * is not destroyed before the fop is complete - */ - GF_REF_GET (glfd); - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - errno = EBADFD; - goto out; - } - - frame = syncop_create_frame (THIS); - if (!frame) { - errno = ENOMEM; - goto out; - } - - gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t); - if (!gio) { - errno = ENOMEM; - goto out; - } - - gio->op = GF_FOP_ZEROFILL; - gio->glfd = glfd; - gio->offset = offset; - gio->count = len; - gio->oldcb = oldcb; - gio->fn = fn; - gio->data = data; - - frame->local = gio; - - ret = get_fop_attr_thrd_key (&fop_attr); - if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); - - STACK_WIND_COOKIE (frame, glfs_zerofill_async_cbk, subvol, subvol, - subvol->fops->zerofill, fd, offset, len, fop_attr); - ret = 0; + struct glfs_io *gio = NULL; + int ret = -1; + call_frame_t *frame = NULL; + xlator_t *subvol = NULL; + fd_t *fd = NULL; + dict_t *fop_attr = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + /* Need to take explicit ref so that the fd + * is not destroyed before the fop is complete + */ + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + errno = EBADFD; + goto out; + } + + frame = syncop_create_frame(THIS); + if (!frame) { + errno = ENOMEM; + goto out; + } + + gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t); + if (!gio) { + errno = ENOMEM; + goto out; + } + + gio->op = GF_FOP_ZEROFILL; + gio->glfd = glfd; + gio->offset = offset; + gio->count = len; + gio->oldcb = oldcb; + gio->fn = fn; + gio->data = data; + + frame->local = gio; + + ret = get_fop_attr_thrd_key(&fop_attr); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); + + STACK_WIND_COOKIE(frame, glfs_zerofill_async_cbk, subvol, subvol, + subvol->fops->zerofill, fd, offset, len, fop_attr); + ret = 0; out: - if (ret) { - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); - GF_FREE (gio); - if (frame) - STACK_DESTROY (frame->root); - glfs_subvol_done (glfd->fs, subvol); - } - if (fop_attr) - dict_unref (fop_attr); + if (ret) { + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); + GF_FREE(gio); + if (frame) + STACK_DESTROY(frame->root); + glfs_subvol_done(glfd->fs, subvol); + } + if (fop_attr) + dict_unref(fop_attr); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } int -pub_glfs_zerofill_async35 (struct glfs_fd *glfd, off_t offset, off_t len, - glfs_io_cbk34 fn, void *data) +pub_glfs_zerofill_async35(struct glfs_fd *glfd, off_t offset, off_t len, + glfs_io_cbk34 fn, void *data) { - return glfs_zerofill_async_common (glfd, offset, len, _gf_true, - (void *)fn, data); + return glfs_zerofill_async_common(glfd, offset, len, _gf_true, (void *)fn, + data); } GFAPI_SYMVER_PUBLIC(glfs_zerofill_async35, glfs_zerofill_async, 3.5.0); - int -pub_glfs_zerofill_async (struct glfs_fd *glfd, off_t offset, off_t len, - glfs_io_cbk fn, void *data) +pub_glfs_zerofill_async(struct glfs_fd *glfd, off_t offset, off_t len, + glfs_io_cbk fn, void *data) { - return glfs_zerofill_async_common (glfd, offset, len, _gf_false, - fn, data); + return glfs_zerofill_async_common(glfd, offset, len, _gf_false, fn, data); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_zerofill_async, future); - void -gf_dirent_to_dirent (gf_dirent_t *gf_dirent, struct dirent *dirent) +gf_dirent_to_dirent(gf_dirent_t *gf_dirent, struct dirent *dirent) { - dirent->d_ino = gf_dirent->d_ino; + dirent->d_ino = gf_dirent->d_ino; #ifdef _DIRENT_HAVE_D_OFF - dirent->d_off = gf_dirent->d_off; + dirent->d_off = gf_dirent->d_off; #endif #ifdef _DIRENT_HAVE_D_TYPE - dirent->d_type = gf_dirent->d_type; + dirent->d_type = gf_dirent->d_type; #endif #ifdef _DIRENT_HAVE_D_NAMLEN - dirent->d_namlen = strlen (gf_dirent->d_name); + dirent->d_namlen = strlen(gf_dirent->d_name); #endif - snprintf (dirent->d_name, NAME_MAX, "%s", gf_dirent->d_name); + snprintf(dirent->d_name, NAME_MAX, "%s", gf_dirent->d_name); } - int -glfd_entry_refresh (struct glfs_fd *glfd, int plus) -{ - xlator_t *subvol = NULL; - gf_dirent_t entries; - gf_dirent_t old; - gf_dirent_t *entry = NULL; - int ret = -1; - fd_t *fd = NULL; - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } - - if (fd->inode->ia_type != IA_IFDIR) { - ret = -1; - errno = EBADF; - goto out; - } - - INIT_LIST_HEAD (&entries.list); - INIT_LIST_HEAD (&old.list); - - if (plus) - ret = syncop_readdirp (subvol, fd, 131072, glfd->offset, - &entries, NULL, NULL); - else - ret = syncop_readdir (subvol, fd, 131072, glfd->offset, - &entries, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - if (ret >= 0) { - if (plus) { - list_for_each_entry (entry, &entries.list, list) { - if (!entry->inode && - !IA_ISDIR (entry->d_stat.ia_type)) { - /* entry->inode for directories will be - * always set to null to force a lookup - * on the dentry. Also we will have - * proper stat if directory present on - * hashed subvolume. - */ - gf_fill_iatt_for_dirent (entry, - fd->inode, - subvol); - } - } - - gf_link_inodes_from_dirent (THIS, fd->inode, &entries); +glfd_entry_refresh(struct glfs_fd *glfd, int plus) +{ + xlator_t *subvol = NULL; + gf_dirent_t entries; + gf_dirent_t old; + gf_dirent_t *entry = NULL; + int ret = -1; + fd_t *fd = NULL; + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + if (fd->inode->ia_type != IA_IFDIR) { + ret = -1; + errno = EBADF; + goto out; + } + + INIT_LIST_HEAD(&entries.list); + INIT_LIST_HEAD(&old.list); + + if (plus) + ret = syncop_readdirp(subvol, fd, 131072, glfd->offset, &entries, NULL, + NULL); + else + ret = syncop_readdir(subvol, fd, 131072, glfd->offset, &entries, NULL, + NULL); + DECODE_SYNCOP_ERR(ret); + if (ret >= 0) { + if (plus) { + list_for_each_entry(entry, &entries.list, list) + { + if (!entry->inode && !IA_ISDIR(entry->d_stat.ia_type)) { + /* entry->inode for directories will be + * always set to null to force a lookup + * on the dentry. Also we will have + * proper stat if directory present on + * hashed subvolume. + */ + gf_fill_iatt_for_dirent(entry, fd->inode, subvol); } + } - list_splice_init (&glfd->entries, &old.list); - list_splice_init (&entries.list, &glfd->entries); + gf_link_inodes_from_dirent(THIS, fd->inode, &entries); + } - /* spurious errno is dangerous for glfd_entry_next() */ - errno = 0; - } + list_splice_init(&glfd->entries, &old.list); + list_splice_init(&entries.list, &glfd->entries); + /* spurious errno is dangerous for glfd_entry_next() */ + errno = 0; + } - if (ret > 0) - glfd->next = list_entry (glfd->entries.next, gf_dirent_t, list); + if (ret > 0) + glfd->next = list_entry(glfd->entries.next, gf_dirent_t, list); - gf_dirent_free (&old); + gf_dirent_free(&old); out: - if (fd) - fd_unref (fd); + if (fd) + fd_unref(fd); - glfs_subvol_done (glfd->fs, subvol); + glfs_subvol_done(glfd->fs, subvol); - return ret; + return ret; } - gf_dirent_t * -glfd_entry_next (struct glfs_fd *glfd, int plus) +glfd_entry_next(struct glfs_fd *glfd, int plus) { - gf_dirent_t *entry = NULL; - int ret = -1; + gf_dirent_t *entry = NULL; + int ret = -1; - if (!glfd->offset || !glfd->next) { - ret = glfd_entry_refresh (glfd, plus); - if (ret < 0) - return NULL; - } + if (!glfd->offset || !glfd->next) { + ret = glfd_entry_refresh(glfd, plus); + if (ret < 0) + return NULL; + } - entry = glfd->next; - if (!entry) - return NULL; + entry = glfd->next; + if (!entry) + return NULL; - if (&entry->next->list == &glfd->entries) - glfd->next = NULL; - else - glfd->next = entry->next; + if (&entry->next->list == &glfd->entries) + glfd->next = NULL; + else + glfd->next = entry->next; - glfd->offset = entry->d_off; + glfd->offset = entry->d_off; - return entry; + return entry; } - struct dirent * -glfs_readdirbuf_get (struct glfs_fd *glfd) +glfs_readdirbuf_get(struct glfs_fd *glfd) { - struct dirent *buf = NULL; + struct dirent *buf = NULL; - LOCK (&glfd->fd->lock); - { - buf = glfd->readdirbuf; - if (buf) { - memset (buf, 0, READDIRBUF_SIZE); - goto unlock; - } - - buf = GF_CALLOC (1, READDIRBUF_SIZE, glfs_mt_readdirbuf_t); - if (!buf) { - errno = ENOMEM; - goto unlock; - } + LOCK(&glfd->fd->lock); + { + buf = glfd->readdirbuf; + if (buf) { + memset(buf, 0, READDIRBUF_SIZE); + goto unlock; + } - glfd->readdirbuf = buf; + buf = GF_CALLOC(1, READDIRBUF_SIZE, glfs_mt_readdirbuf_t); + if (!buf) { + errno = ENOMEM; + goto unlock; } + + glfd->readdirbuf = buf; + } unlock: - UNLOCK (&glfd->fd->lock); + UNLOCK(&glfd->fd->lock); - return buf; + return buf; } - int -pub_glfs_readdirplus_r (struct glfs_fd *glfd, struct stat *stat, - struct dirent *ext, struct dirent **res) +pub_glfs_readdirplus_r(struct glfs_fd *glfd, struct stat *stat, + struct dirent *ext, struct dirent **res) { - int ret = 0; - gf_dirent_t *entry = NULL; - struct dirent *buf = NULL; + int ret = 0; + gf_dirent_t *entry = NULL; + struct dirent *buf = NULL; - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); - GF_REF_GET (glfd); + GF_REF_GET(glfd); - errno = 0; + errno = 0; - if (ext) - buf = ext; - else - buf = glfs_readdirbuf_get (glfd); + if (ext) + buf = ext; + else + buf = glfs_readdirbuf_get(glfd); - if (!buf) { - errno = ENOMEM; - ret = -1; - goto out; - } + if (!buf) { + errno = ENOMEM; + ret = -1; + goto out; + } - entry = glfd_entry_next (glfd, !!stat); - if (errno) - ret = -1; + entry = glfd_entry_next(glfd, !!stat); + if (errno) + ret = -1; - if (res) { - if (entry) - *res = buf; - else - *res = NULL; - } + if (res) { + if (entry) + *res = buf; + else + *res = NULL; + } - if (entry) { - gf_dirent_to_dirent (entry, buf); - if (stat) - glfs_iatt_to_stat (glfd->fs, &entry->d_stat, stat); - } + if (entry) { + gf_dirent_to_dirent(entry, buf); + if (stat) + glfs_iatt_to_stat(glfd->fs, &entry->d_stat, stat); + } out: - if (glfd) - GF_REF_PUT (glfd); + if (glfd) + GF_REF_PUT(glfd); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; - return ret; + return ret; invalid_fs: - return -1; + return -1; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdirplus_r, 3.4.0); - int -pub_glfs_readdir_r (struct glfs_fd *glfd, struct dirent *buf, - struct dirent **res) +pub_glfs_readdir_r(struct glfs_fd *glfd, struct dirent *buf, + struct dirent **res) { - return pub_glfs_readdirplus_r (glfd, 0, buf, res); + return pub_glfs_readdirplus_r(glfd, 0, buf, res); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdir_r, 3.4.0); - struct dirent * -pub_glfs_readdirplus (struct glfs_fd *glfd, struct stat *stat) +pub_glfs_readdirplus(struct glfs_fd *glfd, struct stat *stat) { - struct dirent *res = NULL; - int ret = -1; + struct dirent *res = NULL; + int ret = -1; - ret = pub_glfs_readdirplus_r (glfd, stat, NULL, &res); - if (ret) - return NULL; + ret = pub_glfs_readdirplus_r(glfd, stat, NULL, &res); + if (ret) + return NULL; - return res; + return res; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdirplus, 3.5.0); - struct dirent * -pub_glfs_readdir (struct glfs_fd *glfd) +pub_glfs_readdir(struct glfs_fd *glfd) { - return pub_glfs_readdirplus (glfd, NULL); + return pub_glfs_readdirplus(glfd, NULL); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdir, 3.5.0); - int -pub_glfs_statvfs (struct glfs *fs, const char *path, struct statvfs *buf) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +pub_glfs_statvfs(struct glfs *fs, const char *path, struct statvfs *buf) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval); + ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret) - goto out; + if (ret) + goto out; - ret = syncop_statfs (subvol, &loc, buf, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + ret = syncop_statfs(subvol, &loc, buf, NULL, NULL); + DECODE_SYNCOP_ERR(ret); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); out: - loc_wipe (&loc); + loc_wipe(&loc); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_statvfs, 3.4.0); - int -glfs_setattr (struct glfs *fs, const char *path, struct iatt *iatt, - int valid, int follow) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt riatt = {0, }; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +glfs_setattr(struct glfs *fs, const char *path, struct iatt *iatt, int valid, + int follow) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt riatt = { + 0, + }; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - if (follow) - ret = glfs_resolve (fs, subvol, path, &loc, &riatt, reval); - else - ret = glfs_lresolve (fs, subvol, path, &loc, &riatt, reval); + if (follow) + ret = glfs_resolve(fs, subvol, path, &loc, &riatt, reval); + else + ret = glfs_lresolve(fs, subvol, path, &loc, &riatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret) - goto out; + if (ret) + goto out; - /* TODO : Add leaseid */ - ret = syncop_setattr (subvol, &loc, iatt, valid, 0, 0, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + /* TODO : Add leaseid */ + ret = syncop_setattr(subvol, &loc, iatt, valid, 0, 0, NULL, NULL); + DECODE_SYNCOP_ERR(ret); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); out: - loc_wipe (&loc); + loc_wipe(&loc); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } - int -glfs_fsetattr (struct glfs_fd *glfd, struct iatt *iatt, int valid) -{ - int ret = -1; - xlator_t *subvol = NULL; - fd_t *fd = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - GF_REF_GET (glfd); - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } - - /* TODO : Add leaseid */ - ret = syncop_fsetattr (subvol, fd, iatt, valid, 0, 0, NULL, NULL); - DECODE_SYNCOP_ERR (ret); +glfs_fsetattr(struct glfs_fd *glfd, struct iatt *iatt, int valid) +{ + int ret = -1; + xlator_t *subvol = NULL; + fd_t *fd = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + /* TODO : Add leaseid */ + ret = syncop_fsetattr(subvol, fd, iatt, valid, 0, 0, NULL, NULL); + DECODE_SYNCOP_ERR(ret); out: - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); - glfs_subvol_done (glfd->fs, subvol); + glfs_subvol_done(glfd->fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } - int -pub_glfs_chmod (struct glfs *fs, const char *path, mode_t mode) +pub_glfs_chmod(struct glfs *fs, const char *path, mode_t mode) { - int ret = -1; - struct iatt iatt = {0, }; - int valid = 0; + int ret = -1; + struct iatt iatt = { + 0, + }; + int valid = 0; - iatt.ia_prot = ia_prot_from_st_mode (mode); - valid = GF_SET_ATTR_MODE; + iatt.ia_prot = ia_prot_from_st_mode(mode); + valid = GF_SET_ATTR_MODE; - ret = glfs_setattr (fs, path, &iatt, valid, 1); + ret = glfs_setattr(fs, path, &iatt, valid, 1); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_chmod, 3.4.0); - int -pub_glfs_fchmod (struct glfs_fd *glfd, mode_t mode) +pub_glfs_fchmod(struct glfs_fd *glfd, mode_t mode) { - int ret = -1; - struct iatt iatt = {0, }; - int valid = 0; + int ret = -1; + struct iatt iatt = { + 0, + }; + int valid = 0; - iatt.ia_prot = ia_prot_from_st_mode (mode); - valid = GF_SET_ATTR_MODE; + iatt.ia_prot = ia_prot_from_st_mode(mode); + valid = GF_SET_ATTR_MODE; - ret = glfs_fsetattr (glfd, &iatt, valid); + ret = glfs_fsetattr(glfd, &iatt, valid); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchmod, 3.4.0); - int -pub_glfs_chown (struct glfs *fs, const char *path, uid_t uid, gid_t gid) +pub_glfs_chown(struct glfs *fs, const char *path, uid_t uid, gid_t gid) { - int ret = 0; - int valid = 0; - struct iatt iatt = {0, }; + int ret = 0; + int valid = 0; + struct iatt iatt = { + 0, + }; - if (uid != (uid_t) -1) { - iatt.ia_uid = uid; - valid = GF_SET_ATTR_UID; - } + if (uid != (uid_t)-1) { + iatt.ia_uid = uid; + valid = GF_SET_ATTR_UID; + } - if (gid != (uid_t) -1) { - iatt.ia_gid = gid; - valid = valid | GF_SET_ATTR_GID; - } + if (gid != (uid_t)-1) { + iatt.ia_gid = gid; + valid = valid | GF_SET_ATTR_GID; + } - if (valid) - ret = glfs_setattr (fs, path, &iatt, valid, 1); + if (valid) + ret = glfs_setattr(fs, path, &iatt, valid, 1); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_chown, 3.4.0); - int -pub_glfs_lchown (struct glfs *fs, const char *path, uid_t uid, gid_t gid) +pub_glfs_lchown(struct glfs *fs, const char *path, uid_t uid, gid_t gid) { - int ret = 0; - int valid = 0; - struct iatt iatt = {0, }; + int ret = 0; + int valid = 0; + struct iatt iatt = { + 0, + }; - if (uid != (uid_t) -1) { - iatt.ia_uid = uid; - valid = GF_SET_ATTR_UID; - } + if (uid != (uid_t)-1) { + iatt.ia_uid = uid; + valid = GF_SET_ATTR_UID; + } - if (gid != (uid_t) -1) { - iatt.ia_gid = gid; - valid = valid | GF_SET_ATTR_GID; - } + if (gid != (uid_t)-1) { + iatt.ia_gid = gid; + valid = valid | GF_SET_ATTR_GID; + } - if (valid) - ret = glfs_setattr (fs, path, &iatt, valid, 0); + if (valid) + ret = glfs_setattr(fs, path, &iatt, valid, 0); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lchown, 3.4.0); - int -pub_glfs_fchown (struct glfs_fd *glfd, uid_t uid, gid_t gid) +pub_glfs_fchown(struct glfs_fd *glfd, uid_t uid, gid_t gid) { - int ret = 0; - int valid = 0; - struct iatt iatt = {0, }; + int ret = 0; + int valid = 0; + struct iatt iatt = { + 0, + }; - if (uid != (uid_t) -1) { - iatt.ia_uid = uid; - valid = GF_SET_ATTR_UID; - } + if (uid != (uid_t)-1) { + iatt.ia_uid = uid; + valid = GF_SET_ATTR_UID; + } - if (gid != (uid_t) -1) { - iatt.ia_gid = gid; - valid = valid | GF_SET_ATTR_GID; - } + if (gid != (uid_t)-1) { + iatt.ia_gid = gid; + valid = valid | GF_SET_ATTR_GID; + } - if (valid) - ret = glfs_fsetattr (glfd, &iatt, valid); + if (valid) + ret = glfs_fsetattr(glfd, &iatt, valid); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchown, 3.4.0); - int -pub_glfs_utimens (struct glfs *fs, const char *path, - const struct timespec times[2]) +pub_glfs_utimens(struct glfs *fs, const char *path, + const struct timespec times[2]) { - int ret = -1; - int valid = 0; - struct iatt iatt = {0, }; + int ret = -1; + int valid = 0; + struct iatt iatt = { + 0, + }; - iatt.ia_atime = times[0].tv_sec; - iatt.ia_atime_nsec = times[0].tv_nsec; - iatt.ia_mtime = times[1].tv_sec; - iatt.ia_mtime_nsec = times[1].tv_nsec; + iatt.ia_atime = times[0].tv_sec; + iatt.ia_atime_nsec = times[0].tv_nsec; + iatt.ia_mtime = times[1].tv_sec; + iatt.ia_mtime_nsec = times[1].tv_nsec; - valid = GF_SET_ATTR_ATIME|GF_SET_ATTR_MTIME; + valid = GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME; - ret = glfs_setattr (fs, path, &iatt, valid, 1); + ret = glfs_setattr(fs, path, &iatt, valid, 1); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_utimens, 3.4.0); - int -pub_glfs_lutimens (struct glfs *fs, const char *path, - const struct timespec times[2]) +pub_glfs_lutimens(struct glfs *fs, const char *path, + const struct timespec times[2]) { - int ret = -1; - int valid = 0; - struct iatt iatt = {0, }; + int ret = -1; + int valid = 0; + struct iatt iatt = { + 0, + }; - iatt.ia_atime = times[0].tv_sec; - iatt.ia_atime_nsec = times[0].tv_nsec; - iatt.ia_mtime = times[1].tv_sec; - iatt.ia_mtime_nsec = times[1].tv_nsec; + iatt.ia_atime = times[0].tv_sec; + iatt.ia_atime_nsec = times[0].tv_nsec; + iatt.ia_mtime = times[1].tv_sec; + iatt.ia_mtime_nsec = times[1].tv_nsec; - valid = GF_SET_ATTR_ATIME|GF_SET_ATTR_MTIME; + valid = GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME; - ret = glfs_setattr (fs, path, &iatt, valid, 0); + ret = glfs_setattr(fs, path, &iatt, valid, 0); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lutimens, 3.4.0); - int -pub_glfs_futimens (struct glfs_fd *glfd, const struct timespec times[2]) +pub_glfs_futimens(struct glfs_fd *glfd, const struct timespec times[2]) { - int ret = -1; - int valid = 0; - struct iatt iatt = {0, }; + int ret = -1; + int valid = 0; + struct iatt iatt = { + 0, + }; - iatt.ia_atime = times[0].tv_sec; - iatt.ia_atime_nsec = times[0].tv_nsec; - iatt.ia_mtime = times[1].tv_sec; - iatt.ia_mtime_nsec = times[1].tv_nsec; + iatt.ia_atime = times[0].tv_sec; + iatt.ia_atime_nsec = times[0].tv_nsec; + iatt.ia_mtime = times[1].tv_sec; + iatt.ia_mtime_nsec = times[1].tv_nsec; - valid = GF_SET_ATTR_ATIME|GF_SET_ATTR_MTIME; + valid = GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME; - ret = glfs_fsetattr (glfd, &iatt, valid); + ret = glfs_fsetattr(glfd, &iatt, valid); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_futimens, 3.4.0); - int -glfs_getxattr_process (void *value, size_t size, dict_t *xattr, - const char *name) -{ - data_t *data = NULL; - int ret = -1; - - data = dict_get (xattr, (char *)name); - if (!data) { - errno = ENODATA; - ret = -1; - goto out; - } - - ret = data->len; - if (!value || !size) - goto out; - - if (size < ret) { - ret = -1; - errno = ERANGE; - goto out; - } - - memcpy (value, data->data, ret); -out: - return ret; -} - - -ssize_t -glfs_getxattr_common (struct glfs *fs, const char *path, const char *name, - void *value, size_t size, int follow) +glfs_getxattr_process(void *value, size_t size, dict_t *xattr, const char *name) { - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - dict_t *xattr = NULL; - int reval = 0; + data_t *data = NULL; + int ret = -1; - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + data = dict_get(xattr, (char *)name); + if (!data) { + errno = ENODATA; + ret = -1; + goto out; + } - if (!name || *name == '\0') { - ret = -1; - errno = EINVAL; - goto out; - } + ret = data->len; + if (!value || !size) + goto out; - if (strlen(name) > GF_XATTR_NAME_MAX) { - ret = -1; - errno = ENAMETOOLONG; - goto out; - } + if (size < ret) { + ret = -1; + errno = ERANGE; + goto out; + } + + memcpy(value, data->data, ret); +out: + return ret; +} - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +ssize_t +glfs_getxattr_common(struct glfs *fs, const char *path, const char *name, + void *value, size_t size, int follow) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + dict_t *xattr = NULL; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + if (!name || *name == '\0') { + ret = -1; + errno = EINVAL; + goto out; + } + + if (strlen(name) > GF_XATTR_NAME_MAX) { + ret = -1; + errno = ENAMETOOLONG; + goto out; + } + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - if (follow) - ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval); - else - ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval); + if (follow) + ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval); + else + ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret) - goto out; + if (ret) + goto out; - ret = syncop_getxattr (subvol, &loc, &xattr, name, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + ret = syncop_getxattr(subvol, &loc, &xattr, name, NULL, NULL); + DECODE_SYNCOP_ERR(ret); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret) - goto out; + if (ret) + goto out; - ret = glfs_getxattr_process (value, size, xattr, name); + ret = glfs_getxattr_process(value, size, xattr, name); out: - loc_wipe (&loc); + loc_wipe(&loc); - if (xattr) - dict_unref (xattr); + if (xattr) + dict_unref(xattr); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } - ssize_t -pub_glfs_getxattr (struct glfs *fs, const char *path, const char *name, - void *value, size_t size) +pub_glfs_getxattr(struct glfs *fs, const char *path, const char *name, + void *value, size_t size) { - return glfs_getxattr_common (fs, path, name, value, size, 1); + return glfs_getxattr_common(fs, path, name, value, size, 1); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_getxattr, 3.4.0); - ssize_t -pub_glfs_lgetxattr (struct glfs *fs, const char *path, const char *name, - void *value, size_t size) +pub_glfs_lgetxattr(struct glfs *fs, const char *path, const char *name, + void *value, size_t size) { - return glfs_getxattr_common (fs, path, name, value, size, 0); + return glfs_getxattr_common(fs, path, name, value, size, 0); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lgetxattr, 3.4.0); - ssize_t -pub_glfs_fgetxattr (struct glfs_fd *glfd, const char *name, void *value, - size_t size) -{ - int ret = -1; - xlator_t *subvol = NULL; - dict_t *xattr = NULL; - fd_t *fd = NULL; +pub_glfs_fgetxattr(struct glfs_fd *glfd, const char *name, void *value, + size_t size) +{ + int ret = -1; + xlator_t *subvol = NULL; + dict_t *xattr = NULL; + fd_t *fd = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + if (!name || *name == '\0') { + ret = -1; + errno = EINVAL; + goto out; + } + + if (strlen(name) > GF_XATTR_NAME_MAX) { + ret = -1; + errno = ENAMETOOLONG; + goto out; + } + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + ret = syncop_fgetxattr(subvol, fd, &xattr, name, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + if (ret) + goto out; + + ret = glfs_getxattr_process(value, size, xattr, name); +out: + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); + if (xattr) + dict_unref(xattr); - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); + glfs_subvol_done(glfd->fs, subvol); - GF_REF_GET (glfd); + __GLFS_EXIT_FS; - if (!name || *name == '\0') { - ret = -1; - errno = EINVAL; - goto out; - } - - if (strlen(name) > GF_XATTR_NAME_MAX) { - ret = -1; - errno = ENAMETOOLONG; - goto out; - } - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } - - ret = syncop_fgetxattr (subvol, fd, &xattr, name, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - if (ret) - goto out; - - ret = glfs_getxattr_process (value, size, xattr, name); -out: - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); - if (xattr) - dict_unref (xattr); - - glfs_subvol_done (glfd->fs, subvol); - - __GLFS_EXIT_FS; - -invalid_fs: - return ret; -} - -GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fgetxattr, 3.4.0); +invalid_fs: + return ret; +} +GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fgetxattr, 3.4.0); int -glfs_listxattr_process (void *value, size_t size, dict_t *xattr) +glfs_listxattr_process(void *value, size_t size, dict_t *xattr) { - int ret = -1; + int ret = -1; - if (!xattr) - goto out; + if (!xattr) + goto out; - ret = dict_keys_join (NULL, 0, xattr, NULL); + ret = dict_keys_join(NULL, 0, xattr, NULL); - if (!value || !size) - goto out; + if (!value || !size) + goto out; - if (size < ret) { - ret = -1; - errno = ERANGE; - } else { - dict_keys_join (value, size, xattr, NULL); - } + if (size < ret) { + ret = -1; + errno = ERANGE; + } else { + dict_keys_join(value, size, xattr, NULL); + } out: - return ret; + return ret; } - ssize_t -glfs_listxattr_common (struct glfs *fs, const char *path, void *value, - size_t size, int follow) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - dict_t *xattr = NULL; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +glfs_listxattr_common(struct glfs *fs, const char *path, void *value, + size_t size, int follow) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + dict_t *xattr = NULL; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - if (follow) - ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval); - else - ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval); + if (follow) + ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval); + else + ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret) - goto out; + if (ret) + goto out; - ret = syncop_getxattr (subvol, &loc, &xattr, NULL, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + ret = syncop_getxattr(subvol, &loc, &xattr, NULL, NULL, NULL); + DECODE_SYNCOP_ERR(ret); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret) - goto out; + if (ret) + goto out; - ret = glfs_listxattr_process (value, size, xattr); + ret = glfs_listxattr_process(value, size, xattr); out: - loc_wipe (&loc); + loc_wipe(&loc); - if (xattr) - dict_unref (xattr); + if (xattr) + dict_unref(xattr); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } - ssize_t -pub_glfs_listxattr (struct glfs *fs, const char *path, void *value, size_t size) +pub_glfs_listxattr(struct glfs *fs, const char *path, void *value, size_t size) { - return glfs_listxattr_common (fs, path, value, size, 1); + return glfs_listxattr_common(fs, path, value, size, 1); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_listxattr, 3.4.0); - ssize_t -pub_glfs_llistxattr (struct glfs *fs, const char *path, void *value, size_t size) +pub_glfs_llistxattr(struct glfs *fs, const char *path, void *value, size_t size) { - return glfs_listxattr_common (fs, path, value, size, 0); + return glfs_listxattr_common(fs, path, value, size, 0); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_llistxattr, 3.4.0); - ssize_t -pub_glfs_flistxattr (struct glfs_fd *glfd, void *value, size_t size) -{ - int ret = -1; - xlator_t *subvol = NULL; - dict_t *xattr = NULL; - fd_t *fd = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - GF_REF_GET (glfd); - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } - - ret = syncop_fgetxattr (subvol, fd, &xattr, NULL, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - if (ret) - goto out; - - ret = glfs_listxattr_process (value, size, xattr); +pub_glfs_flistxattr(struct glfs_fd *glfd, void *value, size_t size) +{ + int ret = -1; + xlator_t *subvol = NULL; + dict_t *xattr = NULL; + fd_t *fd = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + ret = syncop_fgetxattr(subvol, fd, &xattr, NULL, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + if (ret) + goto out; + + ret = glfs_listxattr_process(value, size, xattr); out: - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); - if (xattr) - dict_unref (xattr); + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); + if (xattr) + dict_unref(xattr); - glfs_subvol_done (glfd->fs, subvol); + glfs_subvol_done(glfd->fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_flistxattr, 3.4.0); int -glfs_setxattr_common (struct glfs *fs, const char *path, const char *name, - const void *value, size_t size, int flags, int follow) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - dict_t *xattr = NULL; - int reval = 0; - void *value_cp = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - if (!name || *name == '\0') { - ret = -1; - errno = EINVAL; - goto out; - } - - if (strlen(name) > GF_XATTR_NAME_MAX) { - ret = -1; - errno = ENAMETOOLONG; - goto out; - } - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +glfs_setxattr_common(struct glfs *fs, const char *path, const char *name, + const void *value, size_t size, int flags, int follow) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + dict_t *xattr = NULL; + int reval = 0; + void *value_cp = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + if (!name || *name == '\0') { + ret = -1; + errno = EINVAL; + goto out; + } + + if (strlen(name) > GF_XATTR_NAME_MAX) { + ret = -1; + errno = ENAMETOOLONG; + goto out; + } + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - if (follow) - ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval); - else - ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval); + if (follow) + ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval); + else + ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret) - goto out; + if (ret) + goto out; - value_cp = gf_memdup (value, size); - GF_CHECK_ALLOC_AND_LOG (subvol->name, value_cp, ret, "Failed to" - " duplicate setxattr value", out); + value_cp = gf_memdup(value, size); + GF_CHECK_ALLOC_AND_LOG(subvol->name, value_cp, ret, + "Failed to" + " duplicate setxattr value", + out); - xattr = dict_for_key_value (name, value_cp, size, _gf_false); - if (!xattr) { - GF_FREE (value_cp); - ret = -1; - errno = ENOMEM; - goto out; - } + xattr = dict_for_key_value(name, value_cp, size, _gf_false); + if (!xattr) { + GF_FREE(value_cp); + ret = -1; + errno = ENOMEM; + goto out; + } - ret = syncop_setxattr (subvol, &loc, xattr, flags, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + ret = syncop_setxattr(subvol, &loc, xattr, flags, NULL, NULL); + DECODE_SYNCOP_ERR(ret); out: - loc_wipe (&loc); - if (xattr) - dict_unref (xattr); + loc_wipe(&loc); + if (xattr) + dict_unref(xattr); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } - int -pub_glfs_setxattr (struct glfs *fs, const char *path, const char *name, - const void *value, size_t size, int flags) +pub_glfs_setxattr(struct glfs *fs, const char *path, const char *name, + const void *value, size_t size, int flags) { - return glfs_setxattr_common (fs, path, name, value, size, flags, 1); + return glfs_setxattr_common(fs, path, name, value, size, flags, 1); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setxattr, 3.4.0); - int -pub_glfs_lsetxattr (struct glfs *fs, const char *path, const char *name, - const void *value, size_t size, int flags) +pub_glfs_lsetxattr(struct glfs *fs, const char *path, const char *name, + const void *value, size_t size, int flags) { - return glfs_setxattr_common (fs, path, name, value, size, flags, 0); + return glfs_setxattr_common(fs, path, name, value, size, flags, 0); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lsetxattr, 3.4.0); - int -pub_glfs_fsetxattr (struct glfs_fd *glfd, const char *name, const void *value, - size_t size, int flags) -{ - int ret = -1; - xlator_t *subvol = NULL; - dict_t *xattr = NULL; - fd_t *fd = NULL; - void *value_cp = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - GF_REF_GET (glfd); - - if (!name || *name == '\0') { - ret = -1; - errno = EINVAL; - goto out; - } - - if (strlen(name) > GF_XATTR_NAME_MAX) { - ret = -1; - errno = ENAMETOOLONG; - goto out; - } - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } - - value_cp = gf_memdup (value, size); - GF_CHECK_ALLOC_AND_LOG (subvol->name, value_cp, ret, "Failed to" - " duplicate setxattr value", out); - - xattr = dict_for_key_value (name, value_cp, size, _gf_false); - if (!xattr) { - GF_FREE (value_cp); - ret = -1; - errno = ENOMEM; - goto out; - } - - ret = syncop_fsetxattr (subvol, fd, xattr, flags, NULL, NULL); - DECODE_SYNCOP_ERR (ret); +pub_glfs_fsetxattr(struct glfs_fd *glfd, const char *name, const void *value, + size_t size, int flags) +{ + int ret = -1; + xlator_t *subvol = NULL; + dict_t *xattr = NULL; + fd_t *fd = NULL; + void *value_cp = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + if (!name || *name == '\0') { + ret = -1; + errno = EINVAL; + goto out; + } + + if (strlen(name) > GF_XATTR_NAME_MAX) { + ret = -1; + errno = ENAMETOOLONG; + goto out; + } + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + value_cp = gf_memdup(value, size); + GF_CHECK_ALLOC_AND_LOG(subvol->name, value_cp, ret, + "Failed to" + " duplicate setxattr value", + out); + + xattr = dict_for_key_value(name, value_cp, size, _gf_false); + if (!xattr) { + GF_FREE(value_cp); + ret = -1; + errno = ENOMEM; + goto out; + } + + ret = syncop_fsetxattr(subvol, fd, xattr, flags, NULL, NULL); + DECODE_SYNCOP_ERR(ret); out: - if (xattr) - dict_unref (xattr); + if (xattr) + dict_unref(xattr); - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); - glfs_subvol_done (glfd->fs, subvol); + glfs_subvol_done(glfd->fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsetxattr, 3.4.0); - int -glfs_removexattr_common (struct glfs *fs, const char *path, const char *name, - int follow) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +glfs_removexattr_common(struct glfs *fs, const char *path, const char *name, + int follow) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - if (follow) - ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval); - else - ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval); + if (follow) + ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval); + else + ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret) - goto out; + if (ret) + goto out; - ret = syncop_removexattr (subvol, &loc, name, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + ret = syncop_removexattr(subvol, &loc, name, NULL, NULL); + DECODE_SYNCOP_ERR(ret); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); out: - loc_wipe (&loc); + loc_wipe(&loc); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } - int -pub_glfs_removexattr (struct glfs *fs, const char *path, const char *name) +pub_glfs_removexattr(struct glfs *fs, const char *path, const char *name) { - return glfs_removexattr_common (fs, path, name, 1); + return glfs_removexattr_common(fs, path, name, 1); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_removexattr, 3.4.0); - int -pub_glfs_lremovexattr (struct glfs *fs, const char *path, const char *name) +pub_glfs_lremovexattr(struct glfs *fs, const char *path, const char *name) { - return glfs_removexattr_common (fs, path, name, 0); + return glfs_removexattr_common(fs, path, name, 0); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lremovexattr, 3.4.0); - int -pub_glfs_fremovexattr (struct glfs_fd *glfd, const char *name) +pub_glfs_fremovexattr(struct glfs_fd *glfd, const char *name) { - int ret = -1; - xlator_t *subvol = NULL; - fd_t *fd = NULL; + int ret = -1; + xlator_t *subvol = NULL; + fd_t *fd = NULL; - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); - GF_REF_GET (glfd); + GF_REF_GET(glfd); - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } - ret = syncop_fremovexattr (subvol, fd, name, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + ret = syncop_fremovexattr(subvol, fd, name, NULL, NULL); + DECODE_SYNCOP_ERR(ret); out: - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); - glfs_subvol_done (glfd->fs, subvol); + glfs_subvol_done(glfd->fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fremovexattr, 3.4.0); - int -pub_glfs_fallocate (struct glfs_fd *glfd, int keep_size, off_t offset, size_t len) -{ - int ret = -1; - xlator_t *subvol = NULL; - fd_t *fd = NULL; - dict_t *fop_attr = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - GF_REF_GET (glfd); - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } - - ret = get_fop_attr_thrd_key (&fop_attr); - if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); - - ret = syncop_fallocate (subvol, fd, keep_size, offset, len, fop_attr, NULL); - DECODE_SYNCOP_ERR (ret); +pub_glfs_fallocate(struct glfs_fd *glfd, int keep_size, off_t offset, + size_t len) +{ + int ret = -1; + xlator_t *subvol = NULL; + fd_t *fd = NULL; + dict_t *fop_attr = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + ret = get_fop_attr_thrd_key(&fop_attr); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); + + ret = syncop_fallocate(subvol, fd, keep_size, offset, len, fop_attr, NULL); + DECODE_SYNCOP_ERR(ret); out: - if (fd) - fd_unref(fd); - if (glfd) - GF_REF_PUT (glfd); - if (fop_attr) - dict_unref (fop_attr); + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); + if (fop_attr) + dict_unref(fop_attr); - glfs_subvol_done (glfd->fs, subvol); + glfs_subvol_done(glfd->fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fallocate, 3.5.0); - int -pub_glfs_discard (struct glfs_fd *glfd, off_t offset, size_t len) -{ - int ret = -1; - xlator_t *subvol = NULL; - fd_t *fd = NULL; - dict_t *fop_attr = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - GF_REF_GET (glfd); - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } - - ret = get_fop_attr_thrd_key (&fop_attr); - if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); - - ret = syncop_discard (subvol, fd, offset, len, fop_attr, NULL); - DECODE_SYNCOP_ERR (ret); +pub_glfs_discard(struct glfs_fd *glfd, off_t offset, size_t len) +{ + int ret = -1; + xlator_t *subvol = NULL; + fd_t *fd = NULL; + dict_t *fop_attr = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + ret = get_fop_attr_thrd_key(&fop_attr); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); + + ret = syncop_discard(subvol, fd, offset, len, fop_attr, NULL); + DECODE_SYNCOP_ERR(ret); out: - if (fd) - fd_unref(fd); - if (glfd) - GF_REF_PUT (glfd); - if (fop_attr) - dict_unref (fop_attr); + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); + if (fop_attr) + dict_unref(fop_attr); - glfs_subvol_done (glfd->fs, subvol); + glfs_subvol_done(glfd->fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_discard, 3.5.0); - int -pub_glfs_zerofill (struct glfs_fd *glfd, off_t offset, off_t len) +pub_glfs_zerofill(struct glfs_fd *glfd, off_t offset, off_t len) { - int ret = -1; - xlator_t *subvol = NULL; - fd_t *fd = NULL; - dict_t *fop_attr = NULL; + int ret = -1; + xlator_t *subvol = NULL; + fd_t *fd = NULL; + dict_t *fop_attr = NULL; - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); - GF_REF_GET (glfd); + GF_REF_GET(glfd); - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - errno = EIO; - goto out; - } + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + errno = EIO; + goto out; + } - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - errno = EBADFD; - goto out; - } + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + errno = EBADFD; + goto out; + } - ret = get_fop_attr_thrd_key (&fop_attr); - if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); + ret = get_fop_attr_thrd_key(&fop_attr); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); - ret = syncop_zerofill (subvol, fd, offset, len, fop_attr, NULL); - DECODE_SYNCOP_ERR (ret); + ret = syncop_zerofill(subvol, fd, offset, len, fop_attr, NULL); + DECODE_SYNCOP_ERR(ret); out: - if (fd) - fd_unref(fd); - if (glfd) - GF_REF_PUT (glfd); - if (fop_attr) - dict_unref (fop_attr); + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); + if (fop_attr) + dict_unref(fop_attr); - glfs_subvol_done (glfd->fs, subvol); + glfs_subvol_done(glfd->fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_zerofill, 3.5.0); - int -pub_glfs_chdir (struct glfs *fs, const char *path) -{ - int ret = -1; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } +pub_glfs_chdir(struct glfs *fs, const char *path) +{ + int ret = -1; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval); + ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret) - goto out; + if (ret) + goto out; - if (!IA_ISDIR (iatt.ia_type)) { - ret = -1; - errno = ENOTDIR; - goto out; - } + if (!IA_ISDIR(iatt.ia_type)) { + ret = -1; + errno = ENOTDIR; + goto out; + } - glfs_cwd_set (fs, loc.inode); + glfs_cwd_set(fs, loc.inode); out: - loc_wipe (&loc); + loc_wipe(&loc); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_chdir, 3.4.0); - int -pub_glfs_fchdir (struct glfs_fd *glfd) -{ - int ret = -1; - inode_t *inode = NULL; - xlator_t *subvol = NULL; - fd_t *fd = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - GF_REF_GET (glfd); - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } - - inode = fd->inode; - - if (!IA_ISDIR (inode->ia_type)) { - ret = -1; - errno = ENOTDIR; - goto out; - } - - glfs_cwd_set (glfd->fs, inode); - ret = 0; +pub_glfs_fchdir(struct glfs_fd *glfd) +{ + int ret = -1; + inode_t *inode = NULL; + xlator_t *subvol = NULL; + fd_t *fd = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + inode = fd->inode; + + if (!IA_ISDIR(inode->ia_type)) { + ret = -1; + errno = ENOTDIR; + goto out; + } + + glfs_cwd_set(glfd->fs, inode); + ret = 0; out: - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); - glfs_subvol_done (glfd->fs, subvol); + glfs_subvol_done(glfd->fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchdir, 3.4.0); @@ -4626,680 +4679,673 @@ GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchdir, 3.4.0); static gf_boolean_t warn_realpath = _gf_true; /* log once */ static char * -glfs_realpath_common (struct glfs *fs, const char *path, char *resolved_path, - gf_boolean_t warn_deprecated) -{ - int ret = -1; - char *retpath = NULL; - char *allocpath = NULL; - xlator_t *subvol = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - int reval = 0; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - if (resolved_path) - retpath = resolved_path; - else if (warn_deprecated) { - retpath = allocpath = malloc (PATH_MAX + 1); - if (warn_realpath) { - warn_realpath = _gf_false; - gf_log (THIS->name, GF_LOG_WARNING, "this application " - "is compiled against an old version of " - "libgfapi, it should use glfs_free() to " - "release the path returned by " - "glfs_realpath()"); - } - } else { - retpath = allocpath = GLFS_CALLOC (1, PATH_MAX + 1, NULL, - glfs_mt_realpath_t); +glfs_realpath_common(struct glfs *fs, const char *path, char *resolved_path, + gf_boolean_t warn_deprecated) +{ + int ret = -1; + char *retpath = NULL; + char *allocpath = NULL; + xlator_t *subvol = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + int reval = 0; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + if (resolved_path) + retpath = resolved_path; + else if (warn_deprecated) { + retpath = allocpath = malloc(PATH_MAX + 1); + if (warn_realpath) { + warn_realpath = _gf_false; + gf_log(THIS->name, GF_LOG_WARNING, + "this application " + "is compiled against an old version of " + "libgfapi, it should use glfs_free() to " + "release the path returned by " + "glfs_realpath()"); } - - if (!retpath) { - ret = -1; - errno = ENOMEM; - goto out; - } - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } + } else { + retpath = allocpath = GLFS_CALLOC(1, PATH_MAX + 1, NULL, + glfs_mt_realpath_t); + } + + if (!retpath) { + ret = -1; + errno = ENOMEM; + goto out; + } + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } retry: - ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval); + ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval); - ESTALE_RETRY (ret, errno, reval, &loc, retry); + ESTALE_RETRY(ret, errno, reval, &loc, retry); - if (ret) - goto out; + if (ret) + goto out; - if (loc.path) { - snprintf (retpath, PATH_MAX, "%s", loc.path); - } + if (loc.path) { + snprintf(retpath, PATH_MAX, "%s", loc.path); + } out: - loc_wipe (&loc); + loc_wipe(&loc); - if (ret == -1) { - if (warn_deprecated && allocpath) - free (allocpath); - else if (allocpath) - GLFS_FREE (allocpath); - retpath = NULL; - } + if (ret == -1) { + if (warn_deprecated && allocpath) + free(allocpath); + else if (allocpath) + GLFS_FREE(allocpath); + retpath = NULL; + } - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return retpath; + return retpath; } - char * -pub_glfs_realpath34 (struct glfs *fs, const char *path, char *resolved_path) +pub_glfs_realpath34(struct glfs *fs, const char *path, char *resolved_path) { - return glfs_realpath_common (fs, path, resolved_path, _gf_true); + return glfs_realpath_common(fs, path, resolved_path, _gf_true); } GFAPI_SYMVER_PUBLIC(glfs_realpath34, glfs_realpath, 3.4.0); char * -pub_glfs_realpath (struct glfs *fs, const char *path, char *resolved_path) +pub_glfs_realpath(struct glfs *fs, const char *path, char *resolved_path) { - return glfs_realpath_common (fs, path, resolved_path, _gf_false); + return glfs_realpath_common(fs, path, resolved_path, _gf_false); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_realpath, 3.7.17); - char * -pub_glfs_getcwd (struct glfs *fs, char *buf, size_t n) -{ - int ret = -1; - inode_t *inode = NULL; - char *path = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - if (!buf || n < 2) { - ret = -1; - errno = EINVAL; - goto out; - } - - inode = glfs_cwd_get (fs); - - if (!inode) { - strncpy (buf, "/", n); - ret = 0; - goto out; - } - - ret = inode_path (inode, 0, &path); - if (n <= ret) { - ret = -1; - errno = ERANGE; - goto out; - } - - strncpy (buf, path, n); - ret = 0; +pub_glfs_getcwd(struct glfs *fs, char *buf, size_t n) +{ + int ret = -1; + inode_t *inode = NULL; + char *path = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + if (!buf || n < 2) { + ret = -1; + errno = EINVAL; + goto out; + } + + inode = glfs_cwd_get(fs); + + if (!inode) { + strncpy(buf, "/", n); + ret = 0; + goto out; + } + + ret = inode_path(inode, 0, &path); + if (n <= ret) { + ret = -1; + errno = ERANGE; + goto out; + } + + strncpy(buf, path, n); + ret = 0; out: - GF_FREE (path); + GF_FREE(path); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - if (ret < 0) - return NULL; + if (ret < 0) + return NULL; - return buf; + return buf; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_getcwd, 3.4.0); - static void -gf_flock_to_flock (struct gf_flock *gf_flock, struct flock *flock) +gf_flock_to_flock(struct gf_flock *gf_flock, struct flock *flock) { - flock->l_type = gf_flock->l_type; - flock->l_whence = gf_flock->l_whence; - flock->l_start = gf_flock->l_start; - flock->l_len = gf_flock->l_len; - flock->l_pid = gf_flock->l_pid; + flock->l_type = gf_flock->l_type; + flock->l_whence = gf_flock->l_whence; + flock->l_start = gf_flock->l_start; + flock->l_len = gf_flock->l_len; + flock->l_pid = gf_flock->l_pid; } - static void -gf_flock_from_flock (struct gf_flock *gf_flock, struct flock *flock) +gf_flock_from_flock(struct gf_flock *gf_flock, struct flock *flock) { - gf_flock->l_type = flock->l_type; - gf_flock->l_whence = flock->l_whence; - gf_flock->l_start = flock->l_start; - gf_flock->l_len = flock->l_len; - gf_flock->l_pid = flock->l_pid; + gf_flock->l_type = flock->l_type; + gf_flock->l_whence = flock->l_whence; + gf_flock->l_start = flock->l_start; + gf_flock->l_len = flock->l_len; + gf_flock->l_pid = flock->l_pid; } static int -glfs_lock_common (struct glfs_fd *glfd, int cmd, struct flock *flock, - dict_t *xdata) -{ - int ret = -1; - xlator_t *subvol = NULL; - struct gf_flock gf_flock = {0, }; - struct gf_flock saved_flock = {0, }; - fd_t *fd = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); +glfs_lock_common(struct glfs_fd *glfd, int cmd, struct flock *flock, + dict_t *xdata) +{ + int ret = -1; + xlator_t *subvol = NULL; + struct gf_flock gf_flock = { + 0, + }; + struct gf_flock saved_flock = { + 0, + }; + fd_t *fd = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + if (!flock) { + errno = EINVAL; + goto out; + } + + GF_REF_GET(glfd); + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + /* Generate glusterfs flock structure from client flock + * structure to be processed by server */ + gf_flock_from_flock(&gf_flock, flock); + + /* Keep another copy of flock for split/merge of locks + * at client side */ + gf_flock_from_flock(&saved_flock, flock); + + if (glfd->lk_owner.len != 0) { + ret = syncopctx_setfslkowner(&glfd->lk_owner); - if (!flock) { - errno = EINVAL; - goto out; - } - - GF_REF_GET (glfd); - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { - ret = -1; - errno = EBADFD; - goto out; - } - - /* Generate glusterfs flock structure from client flock - * structure to be processed by server */ - gf_flock_from_flock (&gf_flock, flock); + if (ret) + goto out; + } - /* Keep another copy of flock for split/merge of locks - * at client side */ - gf_flock_from_flock (&saved_flock, flock); + ret = get_fop_attr_thrd_key(&xdata); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); - if (glfd->lk_owner.len != 0) { - ret = syncopctx_setfslkowner (&glfd->lk_owner); + ret = syncop_lk(subvol, fd, cmd, &gf_flock, xdata, NULL); + DECODE_SYNCOP_ERR(ret); - if (ret) - goto out; - } + /* Convert back from gf_flock to flock as expected by application */ + gf_flock_to_flock(&gf_flock, flock); - ret = get_fop_attr_thrd_key (&xdata); - if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); - - ret = syncop_lk (subvol, fd, cmd, &gf_flock, xdata, NULL); - DECODE_SYNCOP_ERR (ret); - - /* Convert back from gf_flock to flock as expected by application */ - gf_flock_to_flock (&gf_flock, flock); - - if (ret == 0 && (cmd == F_SETLK || cmd == F_SETLKW)) { - ret = fd_lk_insert_and_merge (fd, cmd, &saved_flock); - if (ret) { - gf_msg (THIS->name, GF_LOG_ERROR, 0, - API_MSG_LOCK_INSERT_MERGE_FAILED, - "Lock insertion and splitting/merging failed " - "on gfid %s", uuid_utoa (fd->inode->gfid)); - ret = 0; - } + if (ret == 0 && (cmd == F_SETLK || cmd == F_SETLKW)) { + ret = fd_lk_insert_and_merge(fd, cmd, &saved_flock); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, + API_MSG_LOCK_INSERT_MERGE_FAILED, + "Lock insertion and splitting/merging failed " + "on gfid %s", + uuid_utoa(fd->inode->gfid)); + ret = 0; } + } out: - if (fd) - fd_unref (fd); - if (glfd) - GF_REF_PUT (glfd); + if (fd) + fd_unref(fd); + if (glfd) + GF_REF_PUT(glfd); - glfs_subvol_done (glfd->fs, subvol); + glfs_subvol_done(glfd->fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } int -pub_glfs_file_lock (struct glfs_fd *glfd, int cmd, struct flock *flock, - glfs_lock_mode_t lk_mode) -{ - int ret = -1; - dict_t *xdata_in = NULL; - - if (lk_mode == GLFS_LK_MANDATORY) { - /* Create a new dictionary */ - xdata_in = dict_new (); - if (xdata_in == NULL) { - ret = -1; - errno = ENOMEM; - goto out; - } +pub_glfs_file_lock(struct glfs_fd *glfd, int cmd, struct flock *flock, + glfs_lock_mode_t lk_mode) +{ + int ret = -1; + dict_t *xdata_in = NULL; + + if (lk_mode == GLFS_LK_MANDATORY) { + /* Create a new dictionary */ + xdata_in = dict_new(); + if (xdata_in == NULL) { + ret = -1; + errno = ENOMEM; + goto out; + } - /* Set GF_LK_MANDATORY internally within dictionary to map - * GLFS_LK_MANDATORY */ - ret = dict_set_uint32 (xdata_in, GF_LOCK_MODE, GF_LK_MANDATORY); - if (ret) { - gf_msg (THIS->name, GF_LOG_ERROR, 0, - API_MSG_SETTING_LOCK_TYPE_FAILED, - "Setting lock type failed"); - ret = -1; - errno = ENOMEM; - goto out; - } + /* Set GF_LK_MANDATORY internally within dictionary to map + * GLFS_LK_MANDATORY */ + ret = dict_set_uint32(xdata_in, GF_LOCK_MODE, GF_LK_MANDATORY); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, + API_MSG_SETTING_LOCK_TYPE_FAILED, + "Setting lock type failed"); + ret = -1; + errno = ENOMEM; + goto out; } + } - ret = glfs_lock_common (glfd, cmd, flock, xdata_in); + ret = glfs_lock_common(glfd, cmd, flock, xdata_in); out: - if (xdata_in) - dict_unref (xdata_in); + if (xdata_in) + dict_unref(xdata_in); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_file_lock, 4.0.0); int -pub_glfs_posix_lock (struct glfs_fd *glfd, int cmd, struct flock *flock) +pub_glfs_posix_lock(struct glfs_fd *glfd, int cmd, struct flock *flock) { - return glfs_lock_common (glfd, cmd, flock, NULL); + return glfs_lock_common(glfd, cmd, flock, NULL); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_posix_lock, 3.4.0); int -pub_glfs_fd_set_lkowner (struct glfs_fd *glfd, void *data, int len) +pub_glfs_fd_set_lkowner(struct glfs_fd *glfd, void *data, int len) { - int ret = -1; + int ret = -1; - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); - if (!GF_REF_GET (glfd)) { - goto invalid_fs; - } + if (!GF_REF_GET(glfd)) { + goto invalid_fs; + } - GF_VALIDATE_OR_GOTO (THIS->name, data, out); + GF_VALIDATE_OR_GOTO(THIS->name, data, out); - if ((len <= 0) || (len > GFAPI_MAX_LOCK_OWNER_LEN)) { - errno = EINVAL; - gf_msg (THIS->name, GF_LOG_ERROR, errno, - LG_MSG_INVALID_ARG, - "Invalid lk_owner len (%d)", len); - goto out; - } + if ((len <= 0) || (len > GFAPI_MAX_LOCK_OWNER_LEN)) { + errno = EINVAL; + gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG, + "Invalid lk_owner len (%d)", len); + goto out; + } - glfd->lk_owner.len = len; + glfd->lk_owner.len = len; - memcpy (glfd->lk_owner.data, data, len); + memcpy(glfd->lk_owner.data, data, len); - ret = 0; + ret = 0; out: - if (glfd) - GF_REF_PUT (glfd); + if (glfd) + GF_REF_PUT(glfd); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fd_set_lkowner, 3.10.7); struct glfs_fd * -pub_glfs_dup (struct glfs_fd *glfd) -{ - xlator_t *subvol = NULL; - fd_t *fd = NULL; - struct glfs_fd *dupfd = NULL; - struct glfs *fs = NULL; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - GF_REF_GET (glfd); - - fs = glfd->fs; - subvol = glfs_active_subvol (fs); - if (!subvol) { - errno = EIO; - goto out; - } - - fd = glfs_resolve_fd (fs, subvol, glfd); - if (!fd) { - errno = EBADFD; - goto out; - } - - dupfd = glfs_fd_new (fs); - if (!dupfd) { - errno = ENOMEM; - goto out; - } - - dupfd->fd = fd_ref (fd); - dupfd->state = glfd->state; +pub_glfs_dup(struct glfs_fd *glfd) +{ + xlator_t *subvol = NULL; + fd_t *fd = NULL; + struct glfs_fd *dupfd = NULL; + struct glfs *fs = NULL; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + fs = glfd->fs; + subvol = glfs_active_subvol(fs); + if (!subvol) { + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(fs, subvol, glfd); + if (!fd) { + errno = EBADFD; + goto out; + } + + dupfd = glfs_fd_new(fs); + if (!dupfd) { + errno = ENOMEM; + goto out; + } + + dupfd->fd = fd_ref(fd); + dupfd->state = glfd->state; out: - if (fd) - fd_unref (fd); - if (dupfd) - glfs_fd_bind (dupfd); - if (glfd) - GF_REF_PUT (glfd); + if (fd) + fd_unref(fd); + if (dupfd) + glfs_fd_bind(dupfd); + if (glfd) + GF_REF_PUT(glfd); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return dupfd; + return dupfd; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_dup, 3.4.0); static void -glfs_enqueue_upcall_data (struct glfs *fs, struct gf_upcall *upcall_data) +glfs_enqueue_upcall_data(struct glfs *fs, struct gf_upcall *upcall_data) { - int ret = -1; - upcall_entry *u_list = NULL; + int ret = -1; + upcall_entry *u_list = NULL; - if (!fs || !upcall_data) - goto out; + if (!fs || !upcall_data) + goto out; - u_list = GF_CALLOC (1, sizeof(*u_list), - glfs_mt_upcall_entry_t); + u_list = GF_CALLOC(1, sizeof(*u_list), glfs_mt_upcall_entry_t); - if (!u_list) { - gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED, - "Upcall entry allocation failed."); - goto out; - } + if (!u_list) { + gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED, + "Upcall entry allocation failed."); + goto out; + } - INIT_LIST_HEAD (&u_list->upcall_list); + INIT_LIST_HEAD(&u_list->upcall_list); - gf_uuid_copy (u_list->upcall_data.gfid, upcall_data->gfid); - u_list->upcall_data.event_type = upcall_data->event_type; + gf_uuid_copy(u_list->upcall_data.gfid, upcall_data->gfid); + u_list->upcall_data.event_type = upcall_data->event_type; - switch (upcall_data->event_type) { + switch (upcall_data->event_type) { case GF_UPCALL_CACHE_INVALIDATION: - ret = glfs_get_upcall_cache_invalidation (&u_list->upcall_data, - upcall_data); - break; + ret = glfs_get_upcall_cache_invalidation(&u_list->upcall_data, + upcall_data); + break; case GF_UPCALL_RECALL_LEASE: - ret = glfs_get_upcall_lease (&u_list->upcall_data, - upcall_data); - break; + ret = glfs_get_upcall_lease(&u_list->upcall_data, upcall_data); + break; default: - break; - } + break; + } - if (ret) { - gf_msg (THIS->name, GF_LOG_ERROR, errno, - API_MSG_INVALID_ENTRY, - "Upcall entry validation failed."); - goto out; - } + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INVALID_ENTRY, + "Upcall entry validation failed."); + goto out; + } - pthread_mutex_lock (&fs->upcall_list_mutex); - { - list_add_tail (&u_list->upcall_list, - &fs->upcall_list); - } - pthread_mutex_unlock (&fs->upcall_list_mutex); + pthread_mutex_lock(&fs->upcall_list_mutex); + { + list_add_tail(&u_list->upcall_list, &fs->upcall_list); + } + pthread_mutex_unlock(&fs->upcall_list_mutex); - ret = 0; + ret = 0; out: - if (ret && u_list) { - GF_FREE (u_list->upcall_data.data); - GF_FREE(u_list); - } + if (ret && u_list) { + GF_FREE(u_list->upcall_data.data); + GF_FREE(u_list); + } } static void -glfs_free_upcall_lease (void *to_free) +glfs_free_upcall_lease(void *to_free) { - struct glfs_upcall_lease *arg = to_free; + struct glfs_upcall_lease *arg = to_free; - if (!arg) - return; + if (!arg) + return; - if (arg->object) - glfs_h_close (arg->object); + if (arg->object) + glfs_h_close(arg->object); - GF_FREE (arg); + GF_FREE(arg); } int -glfs_recall_lease_fd (struct glfs *fs, - struct gf_upcall *up_data) -{ - struct gf_upcall_recall_lease *recall_lease = NULL; - xlator_t *subvol = NULL; - int ret = 0; - inode_t *inode = NULL; - struct glfs_fd *glfd = NULL; - struct glfs_fd *tmp = NULL; - struct list_head glfd_list = { 0, }; - fd_t *fd = NULL; - uint64_t value = 0; - struct glfs_lease lease = {0, }; - - GF_VALIDATE_OR_GOTO ("gfapi", up_data, out); - GF_VALIDATE_OR_GOTO ("gfapi", fs, out); - - recall_lease = up_data->data; - GF_VALIDATE_OR_GOTO ("gfapi", recall_lease, out); - - INIT_LIST_HEAD(&glfd_list); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - gf_msg_debug (THIS->name, 0, - "Recall lease received for gfid:%s", - uuid_utoa(up_data->gfid)); - - - inode = inode_find (subvol->itable, up_data->gfid); - if (!inode) { - ret = -1; - gf_msg (THIS->name, GF_LOG_ERROR, errno, - API_MSG_INODE_FIND_FAILED, - "Unable to find inode entry for gfid:%s graph id:%d", - uuid_utoa(up_data->gfid), subvol->graph->id); - goto out; +glfs_recall_lease_fd(struct glfs *fs, struct gf_upcall *up_data) +{ + struct gf_upcall_recall_lease *recall_lease = NULL; + xlator_t *subvol = NULL; + int ret = 0; + inode_t *inode = NULL; + struct glfs_fd *glfd = NULL; + struct glfs_fd *tmp = NULL; + struct list_head glfd_list = { + 0, + }; + fd_t *fd = NULL; + uint64_t value = 0; + struct glfs_lease lease = { + 0, + }; + + GF_VALIDATE_OR_GOTO("gfapi", up_data, out); + GF_VALIDATE_OR_GOTO("gfapi", fs, out); + + recall_lease = up_data->data; + GF_VALIDATE_OR_GOTO("gfapi", recall_lease, out); + + INIT_LIST_HEAD(&glfd_list); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + gf_msg_debug(THIS->name, 0, "Recall lease received for gfid:%s", + uuid_utoa(up_data->gfid)); + + inode = inode_find(subvol->itable, up_data->gfid); + if (!inode) { + ret = -1; + gf_msg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INODE_FIND_FAILED, + "Unable to find inode entry for gfid:%s graph id:%d", + uuid_utoa(up_data->gfid), subvol->graph->id); + goto out; + } + + LOCK(&inode->lock); + { + list_for_each_entry(fd, &inode->fd_list, inode_list) + { + ret = fd_ctx_get(fd, subvol, &value); + glfd = (struct glfs_fd *)value; + if (glfd) { + gf_msg_trace(THIS->name, 0, "glfd (%p) has held lease", glfd); + GF_REF_GET(glfd); + list_add_tail(&glfd->list, &glfd_list); + } } + } + UNLOCK(&inode->lock); - LOCK (&inode->lock); + list_for_each_entry_safe(glfd, tmp, &glfd_list, list) + { + LOCK(&glfd->lock); { - list_for_each_entry (fd, &inode->fd_list, inode_list) { - ret = fd_ctx_get (fd, subvol, &value); - glfd = (struct glfs_fd *) value; - if (glfd) { - gf_msg_trace (THIS->name, 0, - "glfd (%p) has held lease", glfd); - GF_REF_GET (glfd); - list_add_tail (&glfd->list, &glfd_list); - } - } + if (glfd->state != GLFD_CLOSE) { + gf_msg_trace(THIS->name, 0, + "glfd (%p) has held lease, " + "calling recall cbk", + glfd); + glfd->cbk(lease, glfd->cookie); + } } - UNLOCK (&inode->lock); - - list_for_each_entry_safe (glfd, tmp, &glfd_list, list) { - LOCK (&glfd->lock); - { - if (glfd->state != GLFD_CLOSE) { - gf_msg_trace (THIS->name, 0, - "glfd (%p) has held lease, " - "calling recall cbk", glfd); - glfd->cbk (lease, glfd->cookie); - } - } - UNLOCK (&glfd->lock); + UNLOCK(&glfd->lock); - list_del_init (&glfd->list); - GF_REF_PUT (glfd); - } + list_del_init(&glfd->list); + GF_REF_PUT(glfd); + } out: - return ret; + return ret; } int -glfs_recall_lease_upcall (struct glfs *fs, - struct glfs_upcall *up_arg, - struct gf_upcall *up_data) -{ - struct gf_upcall_recall_lease *recall_lease = NULL; - struct glfs_object *object = NULL; - xlator_t *subvol = NULL; - int ret = -1; - struct glfs_upcall_lease *up_lease_arg = NULL; - - GF_VALIDATE_OR_GOTO ("gfapi", up_data, out); - GF_VALIDATE_OR_GOTO ("gfapi", fs, out); - - recall_lease = up_data->data; - GF_VALIDATE_OR_GOTO ("gfapi", recall_lease, out); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - errno = EIO; - goto out; - } - - gf_msg_debug (THIS->name, 0, - "Recall lease received for gfid:%s", - uuid_utoa(up_data->gfid)); - - object = glfs_h_find_handle (fs, up_data->gfid, - GFAPI_HANDLE_LENGTH); - if (!object) { - /* The reason handle creation will fail is because we - * couldn't find the inode in the gfapi inode table. - * - * But since application would have taken inode_ref, the - * only case when this can happen is when it has closed - * the handle and hence will no more be interested in - * the upcall for this particular gfid. - */ - gf_msg (THIS->name, GF_LOG_DEBUG, errno, - API_MSG_CREATE_HANDLE_FAILED, - "handle creation of %s failed", - uuid_utoa (up_data->gfid)); - errno = ESTALE; - goto out; - } - - up_lease_arg = GF_CALLOC (1, sizeof (struct glfs_upcall_lease), - glfs_mt_upcall_inode_t); - up_lease_arg->object = object; +glfs_recall_lease_upcall(struct glfs *fs, struct glfs_upcall *up_arg, + struct gf_upcall *up_data) +{ + struct gf_upcall_recall_lease *recall_lease = NULL; + struct glfs_object *object = NULL; + xlator_t *subvol = NULL; + int ret = -1; + struct glfs_upcall_lease *up_lease_arg = NULL; + + GF_VALIDATE_OR_GOTO("gfapi", up_data, out); + GF_VALIDATE_OR_GOTO("gfapi", fs, out); + + recall_lease = up_data->data; + GF_VALIDATE_OR_GOTO("gfapi", recall_lease, out); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + errno = EIO; + goto out; + } + + gf_msg_debug(THIS->name, 0, "Recall lease received for gfid:%s", + uuid_utoa(up_data->gfid)); + + object = glfs_h_find_handle(fs, up_data->gfid, GFAPI_HANDLE_LENGTH); + if (!object) { + /* The reason handle creation will fail is because we + * couldn't find the inode in the gfapi inode table. + * + * But since application would have taken inode_ref, the + * only case when this can happen is when it has closed + * the handle and hence will no more be interested in + * the upcall for this particular gfid. + */ + gf_msg(THIS->name, GF_LOG_DEBUG, errno, API_MSG_CREATE_HANDLE_FAILED, + "handle creation of %s failed", uuid_utoa(up_data->gfid)); + errno = ESTALE; + goto out; + } - GF_VALIDATE_OR_GOTO ("glfs_recall_lease", - up_lease_arg, out); + up_lease_arg = GF_CALLOC(1, sizeof(struct glfs_upcall_lease), + glfs_mt_upcall_inode_t); + up_lease_arg->object = object; + GF_VALIDATE_OR_GOTO("glfs_recall_lease", up_lease_arg, out); - up_lease_arg->lease_type = recall_lease->lease_type; + up_lease_arg->lease_type = recall_lease->lease_type; - up_arg->reason = GF_UPCALL_RECALL_LEASE; - up_arg->event = up_lease_arg; - up_arg->free_event = glfs_free_upcall_lease; + up_arg->reason = GF_UPCALL_RECALL_LEASE; + up_arg->event = up_lease_arg; + up_arg->free_event = glfs_free_upcall_lease; - ret = 0; + ret = 0; out: - if (ret) { - /* Close p_object and oldp_object as well if being referenced.*/ - if (object) - glfs_h_close (object); + if (ret) { + /* Close p_object and oldp_object as well if being referenced.*/ + if (object) + glfs_h_close(object); - /* Set reason to prevent applications from using ->event */ - up_arg->reason = GF_UPCALL_EVENT_NULL; - } - return ret; + /* Set reason to prevent applications from using ->event */ + up_arg->reason = GF_UPCALL_EVENT_NULL; + } + return ret; } static void -glfs_cbk_upcall_data (struct glfs *fs, struct gf_upcall *upcall_data) +glfs_cbk_upcall_data(struct glfs *fs, struct gf_upcall *upcall_data) { - int ret = -1; - struct glfs_upcall *up_arg = NULL; + int ret = -1; + struct glfs_upcall *up_arg = NULL; - if (!fs || !upcall_data) - goto out; + if (!fs || !upcall_data) + goto out; - if (!(fs->upcall_events & upcall_data->event_type)) { - /* ignore events which application hasn't registered*/ - goto out; - } + if (!(fs->upcall_events & upcall_data->event_type)) { + /* ignore events which application hasn't registered*/ + goto out; + } - up_arg = GLFS_CALLOC (1, sizeof (struct gf_upcall), - glfs_release_upcall, - glfs_mt_upcall_entry_t); - if (!up_arg) { - gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED, - "Upcall entry allocation failed."); - goto out; - } + up_arg = GLFS_CALLOC(1, sizeof(struct gf_upcall), glfs_release_upcall, + glfs_mt_upcall_entry_t); + if (!up_arg) { + gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED, + "Upcall entry allocation failed."); + goto out; + } - switch (upcall_data->event_type) { + switch (upcall_data->event_type) { case GF_UPCALL_CACHE_INVALIDATION: - ret = glfs_h_poll_cache_invalidation (fs, up_arg, upcall_data); - break; + ret = glfs_h_poll_cache_invalidation(fs, up_arg, upcall_data); + break; case GF_UPCALL_RECALL_LEASE: - ret = glfs_recall_lease_upcall (fs, up_arg, upcall_data); - break; + ret = glfs_recall_lease_upcall(fs, up_arg, upcall_data); + break; default: - errno = EINVAL; - } - - if (!ret && (up_arg->reason != GLFS_UPCALL_EVENT_NULL)) { - /* It could so happen that the file which got - * upcall notification may have got deleted by - * the same client. In such cases up_arg->reason - * is set to GLFS_UPCALL_EVENT_NULL. No need to - * send upcall then */ - (fs->up_cbk) (up_arg, fs->up_data); - } else if (up_arg->reason == GLFS_UPCALL_EVENT_NULL) { - gf_msg (THIS->name, GF_LOG_DEBUG, errno, - API_MSG_INVALID_ENTRY, - "Upcall_EVENT_NULL received. Skipping it."); - goto out; - } else { - gf_msg (THIS->name, GF_LOG_ERROR, errno, - API_MSG_INVALID_ENTRY, - "Upcall entry validation failed."); - goto out; - } - - /* application takes care of calling glfs_free on up_arg post - * their processing */ - ret = 0; + errno = EINVAL; + } + + if (!ret && (up_arg->reason != GLFS_UPCALL_EVENT_NULL)) { + /* It could so happen that the file which got + * upcall notification may have got deleted by + * the same client. In such cases up_arg->reason + * is set to GLFS_UPCALL_EVENT_NULL. No need to + * send upcall then */ + (fs->up_cbk)(up_arg, fs->up_data); + } else if (up_arg->reason == GLFS_UPCALL_EVENT_NULL) { + gf_msg(THIS->name, GF_LOG_DEBUG, errno, API_MSG_INVALID_ENTRY, + "Upcall_EVENT_NULL received. Skipping it."); + goto out; + } else { + gf_msg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INVALID_ENTRY, + "Upcall entry validation failed."); + goto out; + } + + /* application takes care of calling glfs_free on up_arg post + * their processing */ + ret = 0; out: - if (ret && up_arg) { - GLFS_FREE (up_arg); - } + if (ret && up_arg) { + GLFS_FREE(up_arg); + } - return; + return; } /* @@ -5317,251 +5363,254 @@ out: * to be read/polled by the applications. */ void -priv_glfs_process_upcall_event (struct glfs *fs, void *data) +priv_glfs_process_upcall_event(struct glfs *fs, void *data) { - glusterfs_ctx_t *ctx = NULL; - struct gf_upcall *upcall_data = NULL; + glusterfs_ctx_t *ctx = NULL; + struct gf_upcall *upcall_data = NULL; - DECLARE_OLD_THIS; + DECLARE_OLD_THIS; - gf_msg_debug (THIS->name, 0, - "Upcall gfapi callback is called"); + gf_msg_debug(THIS->name, 0, "Upcall gfapi callback is called"); - __GLFS_ENTRY_VALIDATE_FS (fs, err); + __GLFS_ENTRY_VALIDATE_FS(fs, err); - if (!data) - goto out; + if (!data) + goto out; - /* Unlike in I/O path, "glfs_fini" would not have freed - * 'fs' by the time we take lock as it waits for all epoll - * threads to exit including this - */ - pthread_mutex_lock (&fs->mutex); - { - ctx = fs->ctx; - - /* if we're not interested in upcalls (anymore), skip them */ - if (ctx->cleanup_started || !fs->cache_upcalls) { - pthread_mutex_unlock (&fs->mutex); - goto out; - } + /* Unlike in I/O path, "glfs_fini" would not have freed + * 'fs' by the time we take lock as it waits for all epoll + * threads to exit including this + */ + pthread_mutex_lock(&fs->mutex); + { + ctx = fs->ctx; - fs->pin_refcnt++; + /* if we're not interested in upcalls (anymore), skip them */ + if (ctx->cleanup_started || !fs->cache_upcalls) { + pthread_mutex_unlock(&fs->mutex); + goto out; } - pthread_mutex_unlock (&fs->mutex); - upcall_data = (struct gf_upcall *)data; - - gf_msg_trace (THIS->name, 0, "Upcall gfapi gfid = %s" , - (char *)(upcall_data->gfid)); - - /* * - * TODO: RECALL LEASE for each glfd - * - * In case of RECALL_LEASE, we could associate separate - * cbk function for each glfd either by - * - extending pub_glfs_lease to accept new args (recall_cbk_fn, cookie) - * - or by defining new API "glfs_register_recall_cbk_fn (glfd, recall_cbk_fn, cookie) - * . In such cases, flag it and instead of calling below upcall functions, define - * a new one to go through the glfd list and invoke each of theirs recall_cbk_fn. - * */ - - if (fs->up_cbk) { /* upcall cbk registered */ - (void) glfs_cbk_upcall_data (fs, upcall_data); - } else { - (void) glfs_enqueue_upcall_data (fs, upcall_data); - } - - pthread_mutex_lock (&fs->mutex); - { - fs->pin_refcnt--; - } - pthread_mutex_unlock (&fs->mutex); + fs->pin_refcnt++; + } + pthread_mutex_unlock(&fs->mutex); + + upcall_data = (struct gf_upcall *)data; + + gf_msg_trace(THIS->name, 0, "Upcall gfapi gfid = %s", + (char *)(upcall_data->gfid)); + + /* * + * TODO: RECALL LEASE for each glfd + * + * In case of RECALL_LEASE, we could associate separate + * cbk function for each glfd either by + * - extending pub_glfs_lease to accept new args (recall_cbk_fn, cookie) + * - or by defining new API "glfs_register_recall_cbk_fn (glfd, + * recall_cbk_fn, cookie) . In such cases, flag it and instead of calling + * below upcall functions, define a new one to go through the glfd list and + * invoke each of theirs recall_cbk_fn. + * */ + + if (fs->up_cbk) { /* upcall cbk registered */ + (void)glfs_cbk_upcall_data(fs, upcall_data); + } else { + (void)glfs_enqueue_upcall_data(fs, upcall_data); + } + + pthread_mutex_lock(&fs->mutex); + { + fs->pin_refcnt--; + } + pthread_mutex_unlock(&fs->mutex); out: - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; err: - return; + return; } GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_process_upcall_event, 3.7.0); ssize_t -glfs_anonymous_pwritev (struct glfs *fs, struct glfs_object *object, - const struct iovec *iovec, int iovcnt, - off_t offset, int flags) -{ - xlator_t *subvol = NULL; - struct iobref *iobref = NULL; - struct iobuf *iobuf = NULL; - struct iovec iov = {0, }; - inode_t *inode = NULL; - fd_t *fd = NULL; - int ret = -1; - size_t size = -1; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, object); - if (!inode) { - ret = -1; - errno = ESTALE; - goto out; - } - - fd = fd_anonymous (inode); - if (!fd) { - ret = -1; - gf_msg ("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED, - "Allocating anonymous fd failed"); - errno = ENOMEM; - goto out; - } - - size = iov_length (iovec, iovcnt); - - iobuf = iobuf_get2 (subvol->ctx->iobuf_pool, size); - if (!iobuf) { - ret = -1; - errno = ENOMEM; - goto out; - } - - iobref = iobref_new (); - if (!iobref) { - iobuf_unref (iobuf); - errno = ENOMEM; - ret = -1; - goto out; - } - - ret = iobref_add (iobref, iobuf); - if (ret) { - iobuf_unref (iobuf); - iobref_unref (iobref); - errno = ENOMEM; - ret = -1; - goto out; - } - - iov_unload (iobuf_ptr (iobuf), iovec, iovcnt); - - iov.iov_base = iobuf_ptr (iobuf); - iov.iov_len = size; - - /* TODO : set leaseid */ - ret = syncop_writev (subvol, fd, &iov, 1, offset, iobref, flags, - NULL, NULL, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - - iobuf_unref (iobuf); - iobref_unref (iobref); - - if (ret <= 0) - goto out; +glfs_anonymous_pwritev(struct glfs *fs, struct glfs_object *object, + const struct iovec *iovec, int iovcnt, off_t offset, + int flags) +{ + xlator_t *subvol = NULL; + struct iobref *iobref = NULL; + struct iobuf *iobuf = NULL; + struct iovec iov = { + 0, + }; + inode_t *inode = NULL; + fd_t *fd = NULL; + int ret = -1; + size_t size = -1; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, object); + if (!inode) { + ret = -1; + errno = ESTALE; + goto out; + } + + fd = fd_anonymous(inode); + if (!fd) { + ret = -1; + gf_msg("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED, + "Allocating anonymous fd failed"); + errno = ENOMEM; + goto out; + } + + size = iov_length(iovec, iovcnt); + + iobuf = iobuf_get2(subvol->ctx->iobuf_pool, size); + if (!iobuf) { + ret = -1; + errno = ENOMEM; + goto out; + } + + iobref = iobref_new(); + if (!iobref) { + iobuf_unref(iobuf); + errno = ENOMEM; + ret = -1; + goto out; + } + + ret = iobref_add(iobref, iobuf); + if (ret) { + iobuf_unref(iobuf); + iobref_unref(iobref); + errno = ENOMEM; + ret = -1; + goto out; + } + + iov_unload(iobuf_ptr(iobuf), iovec, iovcnt); + + iov.iov_base = iobuf_ptr(iobuf); + iov.iov_len = size; + + /* TODO : set leaseid */ + ret = syncop_writev(subvol, fd, &iov, 1, offset, iobref, flags, NULL, NULL, + NULL, NULL); + DECODE_SYNCOP_ERR(ret); + + iobuf_unref(iobuf); + iobref_unref(iobref); + + if (ret <= 0) + goto out; out: - if (fd) - fd_unref(fd); + if (fd) + fd_unref(fd); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } ssize_t -glfs_anonymous_preadv (struct glfs *fs, struct glfs_object *object, - const struct iovec *iovec, int iovcnt, - off_t offset, int flags) -{ - xlator_t *subvol = NULL; - struct iovec *iov = NULL; - struct iobref *iobref = NULL; - inode_t *inode = NULL; - fd_t *fd = NULL; - int cnt = 0; - ssize_t ret = -1; - ssize_t size = -1; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, object); - if (!inode) { - ret = -1; - errno = ESTALE; - goto out; - } - - fd = fd_anonymous (inode); - if (!fd) { - ret = -1; - gf_msg ("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED, - "Allocating anonymous fd failed"); - errno = ENOMEM; - goto out; - } - - size = iov_length (iovec, iovcnt); - - /* TODO : set leaseid */ - ret = syncop_readv (subvol, fd, size, offset, flags, &iov, &cnt, - &iobref, NULL, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - if (ret <= 0) - goto out; - - size = iov_copy (iovec, iovcnt, iov, cnt); - - ret = size; +glfs_anonymous_preadv(struct glfs *fs, struct glfs_object *object, + const struct iovec *iovec, int iovcnt, off_t offset, + int flags) +{ + xlator_t *subvol = NULL; + struct iovec *iov = NULL; + struct iobref *iobref = NULL; + inode_t *inode = NULL; + fd_t *fd = NULL; + int cnt = 0; + ssize_t ret = -1; + ssize_t size = -1; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, object); + if (!inode) { + ret = -1; + errno = ESTALE; + goto out; + } + + fd = fd_anonymous(inode); + if (!fd) { + ret = -1; + gf_msg("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED, + "Allocating anonymous fd failed"); + errno = ENOMEM; + goto out; + } + + size = iov_length(iovec, iovcnt); + + /* TODO : set leaseid */ + ret = syncop_readv(subvol, fd, size, offset, flags, &iov, &cnt, &iobref, + NULL, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + if (ret <= 0) + goto out; + + size = iov_copy(iovec, iovcnt, iov, cnt); + + ret = size; out: - if (iov) - GF_FREE (iov); - if (iobref) - iobref_unref (iobref); - if (fd) - fd_unref(fd); + if (iov) + GF_FREE(iov); + if (iobref) + iobref_unref(iobref); + if (fd) + fd_unref(fd); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } -static void glfs_release_xreaddirp_stat (void *ptr) +static void +glfs_release_xreaddirp_stat(void *ptr) { - struct glfs_xreaddirp_stat *to_free = ptr; + struct glfs_xreaddirp_stat *to_free = ptr; - if (to_free->object) - glfs_h_close (to_free->object); + if (to_free->object) + glfs_h_close(to_free->object); } /* @@ -5569,253 +5618,248 @@ static void glfs_release_xreaddirp_stat (void *ptr) * xstat along with dirents. */ int -pub_glfs_xreaddirplus_r (struct glfs_fd *glfd, uint32_t flags, - struct glfs_xreaddirp_stat **xstat_p, - struct dirent *ext, - struct dirent **res) +pub_glfs_xreaddirplus_r(struct glfs_fd *glfd, uint32_t flags, + struct glfs_xreaddirp_stat **xstat_p, + struct dirent *ext, struct dirent **res) { - int ret = -1; - gf_dirent_t *entry = NULL; - struct dirent *buf = NULL; - struct glfs_xreaddirp_stat *xstat = NULL; + int ret = -1; + gf_dirent_t *entry = NULL; + struct dirent *buf = NULL; + struct glfs_xreaddirp_stat *xstat = NULL; - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); - GF_REF_GET (glfd); + GF_REF_GET(glfd); - GF_VALIDATE_OR_GOTO (THIS->name, xstat_p, out); - GF_VALIDATE_OR_GOTO (THIS->name, res, out); + GF_VALIDATE_OR_GOTO(THIS->name, xstat_p, out); + GF_VALIDATE_OR_GOTO(THIS->name, res, out); - errno = 0; + errno = 0; - if (ext) - buf = ext; - else - buf = glfs_readdirbuf_get (glfd); + if (ext) + buf = ext; + else + buf = glfs_readdirbuf_get(glfd); - if (!buf) - goto out; + if (!buf) + goto out; - xstat = GLFS_CALLOC(1, sizeof(struct glfs_xreaddirp_stat), - glfs_release_xreaddirp_stat, - glfs_mt_xreaddirp_stat_t); + xstat = GLFS_CALLOC(1, sizeof(struct glfs_xreaddirp_stat), + glfs_release_xreaddirp_stat, glfs_mt_xreaddirp_stat_t); - if (!xstat) - goto out; + if (!xstat) + goto out; - /* this is readdirplus operation */ - entry = glfd_entry_next (glfd, 1); + /* this is readdirplus operation */ + entry = glfd_entry_next(glfd, 1); - /* XXX: Ideally when we reach EOD, errno should have been - * set to ENOENT. But that doesn't seem to be the case. - * - * The only way to confirm if its EOD at this point is that - * errno == 0 and entry == NULL - */ - if (errno) - goto out; + /* XXX: Ideally when we reach EOD, errno should have been + * set to ENOENT. But that doesn't seem to be the case. + * + * The only way to confirm if its EOD at this point is that + * errno == 0 and entry == NULL + */ + if (errno) + goto out; - if (!entry) { - /* reached EOD, ret = 0 */ - ret = 0; - *res = NULL; - *xstat_p = NULL; - - /* free xstat as applications shall not be using it */ - GLFS_FREE (xstat); - - goto out; - } - - *res = buf; - gf_dirent_to_dirent (entry, buf); - - if (flags & GFAPI_XREADDIRP_STAT) { - glfs_iatt_to_stat (glfd->fs, &entry->d_stat, &xstat->st); - xstat->flags_handled |= GFAPI_XREADDIRP_STAT; - } - - if ((flags & GFAPI_XREADDIRP_HANDLE) && - /* skip . and .. */ - strcmp(buf->d_name, ".") - && strcmp(buf->d_name, "..")) { - - /* Now create object. - * We can use "glfs_h_find_handle" as well as inodes would have - * already got linked as part of 'gf_link_inodes_from_dirent' */ - xstat->object = glfs_h_create_from_handle (glfd->fs, - entry->d_stat.ia_gfid, - GFAPI_HANDLE_LENGTH, - NULL); - - if (xstat->object) { /* success */ - /* note: xstat->object->inode->ref is taken - * This shall be unref'ed when application does - * glfs_free(xstat) */ - xstat->flags_handled |= GFAPI_XREADDIRP_HANDLE; - } + if (!entry) { + /* reached EOD, ret = 0 */ + ret = 0; + *res = NULL; + *xstat_p = NULL; + + /* free xstat as applications shall not be using it */ + GLFS_FREE(xstat); + + goto out; + } + + *res = buf; + gf_dirent_to_dirent(entry, buf); + + if (flags & GFAPI_XREADDIRP_STAT) { + glfs_iatt_to_stat(glfd->fs, &entry->d_stat, &xstat->st); + xstat->flags_handled |= GFAPI_XREADDIRP_STAT; + } + + if ((flags & GFAPI_XREADDIRP_HANDLE) && + /* skip . and .. */ + strcmp(buf->d_name, ".") && strcmp(buf->d_name, "..")) { + /* Now create object. + * We can use "glfs_h_find_handle" as well as inodes would have + * already got linked as part of 'gf_link_inodes_from_dirent' */ + xstat->object = glfs_h_create_from_handle( + glfd->fs, entry->d_stat.ia_gfid, GFAPI_HANDLE_LENGTH, NULL); + + if (xstat->object) { /* success */ + /* note: xstat->object->inode->ref is taken + * This shall be unref'ed when application does + * glfs_free(xstat) */ + xstat->flags_handled |= GFAPI_XREADDIRP_HANDLE; } + } - ret = xstat->flags_handled; - *xstat_p = xstat; + ret = xstat->flags_handled; + *xstat_p = xstat; - gf_msg_debug (THIS->name, 0, - "xreaddirp- requested_flags (%x) , processed_flags (%x)", - flags, xstat->flags_handled); + gf_msg_debug(THIS->name, 0, + "xreaddirp- requested_flags (%x) , processed_flags (%x)", + flags, xstat->flags_handled); out: - GF_REF_PUT (glfd); + GF_REF_PUT(glfd); - if (ret < 0) { - gf_msg (THIS->name, GF_LOG_WARNING, errno, - API_MSG_XREADDIRP_R_FAILED, - "glfs_x_readdirp_r failed - reason (%s)", - strerror(errno)); + if (ret < 0) { + gf_msg(THIS->name, GF_LOG_WARNING, errno, API_MSG_XREADDIRP_R_FAILED, + "glfs_x_readdirp_r failed - reason (%s)", strerror(errno)); - if (xstat) - GLFS_FREE (xstat); - } + if (xstat) + GLFS_FREE(xstat); + } - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; - return ret; + return ret; invalid_fs: - return -1; + return -1; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_xreaddirplus_r, 3.11.0); -struct stat* -pub_glfs_xreaddirplus_get_stat (struct glfs_xreaddirp_stat *xstat) +struct stat * +pub_glfs_xreaddirplus_get_stat(struct glfs_xreaddirp_stat *xstat) { - GF_VALIDATE_OR_GOTO ("glfs_xreaddirplus_get_stat", xstat, out); + GF_VALIDATE_OR_GOTO("glfs_xreaddirplus_get_stat", xstat, out); - if (!xstat->flags_handled & GFAPI_XREADDIRP_STAT) - gf_msg (THIS->name, GF_LOG_ERROR, errno, - LG_MSG_INVALID_ARG, - "GFAPI_XREADDIRP_STAT is not set. Flags" - "handled for xstat(%p) are (%x)", - xstat, xstat->flags_handled); - return &xstat->st; + if (!xstat->flags_handled & GFAPI_XREADDIRP_STAT) + gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG, + "GFAPI_XREADDIRP_STAT is not set. Flags" + "handled for xstat(%p) are (%x)", + xstat, xstat->flags_handled); + return &xstat->st; out: - return NULL; + return NULL; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_xreaddirplus_get_stat, 3.11.0); void -gf_lease_to_glfs_lease (struct gf_lease *gf_lease, struct glfs_lease *lease) +gf_lease_to_glfs_lease(struct gf_lease *gf_lease, struct glfs_lease *lease) { - lease->cmd = gf_lease->cmd; - lease->lease_type = gf_lease->lease_type; - memcpy (lease->lease_id, gf_lease->lease_id, LEASE_ID_SIZE); + lease->cmd = gf_lease->cmd; + lease->lease_type = gf_lease->lease_type; + memcpy(lease->lease_id, gf_lease->lease_id, LEASE_ID_SIZE); } void -glfs_lease_to_gf_lease (struct glfs_lease *lease, struct gf_lease *gf_lease) +glfs_lease_to_gf_lease(struct glfs_lease *lease, struct gf_lease *gf_lease) { - gf_lease->cmd = lease->cmd; - gf_lease->lease_type = lease->lease_type; - memcpy (gf_lease->lease_id, lease->lease_id, LEASE_ID_SIZE); + gf_lease->cmd = lease->cmd; + gf_lease->lease_type = lease->lease_type; + memcpy(gf_lease->lease_id, lease->lease_id, LEASE_ID_SIZE); } int -pub_glfs_lease (struct glfs_fd *glfd, struct glfs_lease *lease, - glfs_recall_cbk fn, void *data) -{ - int ret = -1; - loc_t loc = {0, }; - xlator_t *subvol = NULL; - fd_t *fd = NULL; - struct gf_lease gf_lease = {0, }; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs); - - GF_REF_GET (glfd); - - if (!is_valid_lease_id (lease->lease_id)) { +pub_glfs_lease(struct glfs_fd *glfd, struct glfs_lease *lease, + glfs_recall_cbk fn, void *data) +{ + int ret = -1; + loc_t loc = { + 0, + }; + xlator_t *subvol = NULL; + fd_t *fd = NULL; + struct gf_lease gf_lease = { + 0, + }; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs); + + GF_REF_GET(glfd); + + if (!is_valid_lease_id(lease->lease_id)) { + ret = -1; + errno = EINVAL; + goto out; + } + + subvol = glfs_active_subvol(glfd->fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + fd = glfs_resolve_fd(glfd->fs, subvol, glfd); + if (!fd) { + ret = -1; + errno = EBADFD; + goto out; + } + + switch (lease->lease_type) { + case GLFS_RD_LEASE: + if ((fd->flags != O_RDONLY) && !(fd->flags & O_RDWR)) { ret = -1; errno = EINVAL; goto out; - } - - subvol = glfs_active_subvol (glfd->fs); - if (!subvol) { + } + break; + case GLFS_RW_LEASE: + if (!((fd->flags & O_WRONLY) || (fd->flags & O_RDWR))) { ret = -1; - errno = EIO; + errno = EINVAL; goto out; - } - - fd = glfs_resolve_fd (glfd->fs, subvol, glfd); - if (!fd) { + } + break; + default: + if (lease->cmd != GLFS_GET_LEASE) { ret = -1; - errno = EBADFD; + errno = EINVAL; goto out; - } - - switch (lease->lease_type) { - case GLFS_RD_LEASE: - if ((fd->flags != O_RDONLY) && !(fd->flags & O_RDWR)) { - ret = -1; - errno = EINVAL; - goto out; - } - break; - case GLFS_RW_LEASE: - if (!((fd->flags & O_WRONLY) || (fd->flags & O_RDWR))) { - ret = -1; - errno = EINVAL; - goto out; - } - break; - default: - if (lease->cmd != GLFS_GET_LEASE) { - ret = -1; - errno = EINVAL; - goto out; - } - break; - } + } + break; + } - /* populate loc */ - GLFS_LOC_FILL_INODE (fd->inode, loc, out); + /* populate loc */ + GLFS_LOC_FILL_INODE(fd->inode, loc, out); - glfs_lease_to_gf_lease (lease, &gf_lease); + glfs_lease_to_gf_lease(lease, &gf_lease); - ret = syncop_lease (subvol, &loc, &gf_lease, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + ret = syncop_lease(subvol, &loc, &gf_lease, NULL, NULL); + DECODE_SYNCOP_ERR(ret); - gf_lease_to_glfs_lease (&gf_lease, lease); + gf_lease_to_glfs_lease(&gf_lease, lease); - /* TODO: Add leases for client replay - if (ret == 0 && (cmd == F_SETLK || cmd == F_SETLKW)) - fd_lk_insert_and_merge (fd, cmd, &saved_flock); - */ - if (ret == 0) { - ret = fd_ctx_set (glfd->fd, subvol, (uint64_t)(long)glfd); - if (ret) { - gf_msg (subvol->name, GF_LOG_ERROR, ENOMEM, API_MSG_FDCTX_SET_FAILED, - "Setting fd ctx failed for fd(%p)", glfd->fd); - goto out; - } - glfd->cbk = fn; - glfd->cookie = data; + /* TODO: Add leases for client replay + if (ret == 0 && (cmd == F_SETLK || cmd == F_SETLKW)) + fd_lk_insert_and_merge (fd, cmd, &saved_flock); + */ + if (ret == 0) { + ret = fd_ctx_set(glfd->fd, subvol, (uint64_t)(long)glfd); + if (ret) { + gf_msg(subvol->name, GF_LOG_ERROR, ENOMEM, API_MSG_FDCTX_SET_FAILED, + "Setting fd ctx failed for fd(%p)", glfd->fd); + goto out; } + glfd->cbk = fn; + glfd->cookie = data; + } out: - if (glfd) - GF_REF_PUT (glfd); + if (glfd) + GF_REF_PUT(glfd); - if (subvol) - glfs_subvol_done (glfd->fs, subvol); + if (subvol) + glfs_subvol_done(glfd->fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lease, 4.0.0); diff --git a/api/src/glfs-handleops.c b/api/src/glfs-handleops.c index 343fc384ddf..7e9f4c5c915 100644 --- a/api/src/glfs-handleops.c +++ b/api/src/glfs-handleops.c @@ -8,7 +8,6 @@ * cases as published by the Free Software Foundation. */ - #include "glfs-internal.h" #include "glfs-mem-types.h" #include "syncop.h" @@ -17,1809 +16,1844 @@ #include "gfapi-messages.h" int -glfs_listxattr_process (void *value, size_t size, dict_t *xattr); +glfs_listxattr_process(void *value, size_t size, dict_t *xattr); static void -glfs_iatt_from_stat (struct stat *stat, int valid, struct iatt *iatt, - int *glvalid) +glfs_iatt_from_stat(struct stat *stat, int valid, struct iatt *iatt, + int *glvalid) { - /* validate in args */ - if ((stat == NULL) || (iatt == NULL) || (glvalid == NULL)) { - errno = EINVAL; - return; - } - - *glvalid = 0; - - if (valid & GFAPI_SET_ATTR_MODE) { - iatt->ia_prot = ia_prot_from_st_mode (stat->st_mode); - *glvalid |= GF_SET_ATTR_MODE; - } - - if (valid & GFAPI_SET_ATTR_UID) { - iatt->ia_uid = stat->st_uid; - *glvalid |= GF_SET_ATTR_UID; - } - - if (valid & GFAPI_SET_ATTR_GID) { - iatt->ia_gid = stat->st_gid; - *glvalid |= GF_SET_ATTR_GID; - } - - if (valid & GFAPI_SET_ATTR_ATIME) { - iatt->ia_atime = stat->st_atime; - iatt->ia_atime_nsec = ST_ATIM_NSEC (stat); - *glvalid |= GF_SET_ATTR_ATIME; - } - - if (valid & GFAPI_SET_ATTR_MTIME) { - iatt->ia_mtime = stat->st_mtime; - iatt->ia_mtime_nsec = ST_MTIM_NSEC (stat); - *glvalid |= GF_SET_ATTR_MTIME; - } - + /* validate in args */ + if ((stat == NULL) || (iatt == NULL) || (glvalid == NULL)) { + errno = EINVAL; return; + } + + *glvalid = 0; + + if (valid & GFAPI_SET_ATTR_MODE) { + iatt->ia_prot = ia_prot_from_st_mode(stat->st_mode); + *glvalid |= GF_SET_ATTR_MODE; + } + + if (valid & GFAPI_SET_ATTR_UID) { + iatt->ia_uid = stat->st_uid; + *glvalid |= GF_SET_ATTR_UID; + } + + if (valid & GFAPI_SET_ATTR_GID) { + iatt->ia_gid = stat->st_gid; + *glvalid |= GF_SET_ATTR_GID; + } + + if (valid & GFAPI_SET_ATTR_ATIME) { + iatt->ia_atime = stat->st_atime; + iatt->ia_atime_nsec = ST_ATIM_NSEC(stat); + *glvalid |= GF_SET_ATTR_ATIME; + } + + if (valid & GFAPI_SET_ATTR_MTIME) { + iatt->ia_mtime = stat->st_mtime; + iatt->ia_mtime_nsec = ST_MTIM_NSEC(stat); + *glvalid |= GF_SET_ATTR_MTIME; + } + + return; } struct glfs_object * -pub_glfs_h_lookupat (struct glfs *fs, struct glfs_object *parent, - const char *path, struct stat *stat, int follow) +pub_glfs_h_lookupat(struct glfs *fs, struct glfs_object *parent, + const char *path, struct stat *stat, int follow) { - int ret = 0; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - struct iatt iatt = {0, }; - struct glfs_object *object = NULL; - loc_t loc = {0, }; - - DECLARE_OLD_THIS; - - /* validate in args */ - if (path == NULL) { - errno = EINVAL; - return NULL; - } + int ret = 0; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + struct iatt iatt = { + 0, + }; + struct glfs_object *object = NULL; + loc_t loc = { + 0, + }; + + DECLARE_OLD_THIS; + + /* validate in args */ + if (path == NULL) { + errno = EINVAL; + return NULL; + } - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - errno = EIO; - goto out; - } + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + errno = EIO; + goto out; + } - /* get/refresh the in arg objects inode in correlation to the xlator */ - if (parent) { - inode = glfs_resolve_inode (fs, subvol, parent); - if (!inode) { - errno = ESTALE; - goto out; - } + /* get/refresh the in arg objects inode in correlation to the xlator */ + if (parent) { + inode = glfs_resolve_inode(fs, subvol, parent); + if (!inode) { + errno = ESTALE; + goto out; } + } - /* fop/op */ - ret = glfs_resolve_at (fs, subvol, inode, path, &loc, &iatt, - follow, 0); + /* fop/op */ + ret = glfs_resolve_at(fs, subvol, inode, path, &loc, &iatt, follow, 0); - /* populate out args */ - if (!ret) { - if (stat) - glfs_iatt_to_stat (fs, &iatt, stat); + /* populate out args */ + if (!ret) { + if (stat) + glfs_iatt_to_stat(fs, &iatt, stat); - ret = glfs_create_object (&loc, &object); - } + ret = glfs_create_object(&loc, &object); + } out: - loc_wipe (&loc); + loc_wipe(&loc); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return object; + return object; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_lookupat, 3.7.4); struct glfs_object * -pub_glfs_h_lookupat34 (struct glfs *fs, struct glfs_object *parent, - const char *path, struct stat *stat) +pub_glfs_h_lookupat34(struct glfs *fs, struct glfs_object *parent, + const char *path, struct stat *stat) { - return pub_glfs_h_lookupat (fs, parent, path, stat, 0); + return pub_glfs_h_lookupat(fs, parent, path, stat, 0); } GFAPI_SYMVER_PUBLIC(glfs_h_lookupat34, glfs_h_lookupat, 3.4.2); int -pub_glfs_h_statfs (struct glfs *fs, struct glfs_object *object, - struct statvfs *statvfs) +pub_glfs_h_statfs(struct glfs *fs, struct glfs_object *object, + struct statvfs *statvfs) { - int ret = -1; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - loc_t loc = {0, }; - - DECLARE_OLD_THIS; - - /* validate in args */ - if ((fs == NULL) || (object == NULL || statvfs == NULL)) { - errno = EINVAL; - return -1; - } + int ret = -1; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + loc_t loc = { + 0, + }; + + DECLARE_OLD_THIS; + + /* validate in args */ + if ((fs == NULL) || (object == NULL || statvfs == NULL)) { + errno = EINVAL; + return -1; + } - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, object); - if (!inode) { - errno = ESTALE; - goto out; - } + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, object); + if (!inode) { + errno = ESTALE; + goto out; + } - /* populate loc */ - GLFS_LOC_FILL_INODE (inode, loc, out); + /* populate loc */ + GLFS_LOC_FILL_INODE(inode, loc, out); - /* fop/op */ - ret = syncop_statfs (subvol, &loc, statvfs, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + /* fop/op */ + ret = syncop_statfs(subvol, &loc, statvfs, NULL, NULL); + DECODE_SYNCOP_ERR(ret); - loc_wipe (&loc); + loc_wipe(&loc); out: - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_statfs, 3.7.0); int -pub_glfs_h_stat (struct glfs *fs, struct glfs_object *object, struct stat *stat) +pub_glfs_h_stat(struct glfs *fs, struct glfs_object *object, struct stat *stat) { - int ret = -1; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - - DECLARE_OLD_THIS; - - /* validate in args */ - if ((fs == NULL) || (object == NULL)) { - errno = EINVAL; - return -1; - } - - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, object); - if (!inode) { - errno = ESTALE; - goto out; - } - - /* populate loc */ - GLFS_LOC_FILL_INODE (inode, loc, out); - - /* fop/op */ - ret = syncop_stat (subvol, &loc, &iatt, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - - /* populate out args */ - if (!ret && stat) { - glfs_iatt_to_stat (fs, &iatt, stat); - } + int ret = -1; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + + DECLARE_OLD_THIS; + + /* validate in args */ + if ((fs == NULL) || (object == NULL)) { + errno = EINVAL; + return -1; + } + + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, object); + if (!inode) { + errno = ESTALE; + goto out; + } + + /* populate loc */ + GLFS_LOC_FILL_INODE(inode, loc, out); + + /* fop/op */ + ret = syncop_stat(subvol, &loc, &iatt, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + + /* populate out args */ + if (!ret && stat) { + glfs_iatt_to_stat(fs, &iatt, stat); + } out: - loc_wipe (&loc); + loc_wipe(&loc); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_stat, 3.4.2); - int -pub_glfs_h_getattrs (struct glfs *fs, struct glfs_object *object, - struct stat *stat) +pub_glfs_h_getattrs(struct glfs *fs, struct glfs_object *object, + struct stat *stat) { - int ret = -1; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - struct iatt iatt = {0, }; - - /* validate in args */ - if ((fs == NULL) || (object == NULL)) { - errno = EINVAL; - return -1; - } - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, object); - if (!inode) { - ret = 0; - errno = ESTALE; - goto out; - } + int ret = -1; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + struct iatt iatt = { + 0, + }; + + /* validate in args */ + if ((fs == NULL) || (object == NULL)) { + errno = EINVAL; + return -1; + } + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, object); + if (!inode) { + ret = 0; + errno = ESTALE; + goto out; + } - /* fop/op */ - ret = glfs_resolve_base (fs, subvol, inode, &iatt); + /* fop/op */ + ret = glfs_resolve_base(fs, subvol, inode, &iatt); - /* populate out args */ - if (!ret && stat) { - glfs_iatt_to_stat (fs, &iatt, stat); - } + /* populate out args */ + if (!ret && stat) { + glfs_iatt_to_stat(fs, &iatt, stat); + } out: - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_getattrs, 3.4.2); - int -glfs_h_getxattrs_common (struct glfs *fs, struct glfs_object *object, - dict_t **xattr, const char *name, - gf_boolean_t is_listxattr) +glfs_h_getxattrs_common(struct glfs *fs, struct glfs_object *object, + dict_t **xattr, const char *name, + gf_boolean_t is_listxattr) { - int ret = 0; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - loc_t loc = {0, }; - - /* validate in args */ - if ((fs == NULL) || (object == NULL)) { - errno = EINVAL; - return -1; - } - - if (!is_listxattr) { - if (!name || *name == '\0') { - errno = EINVAL; - return -1; - } - - if (strlen(name) > GF_XATTR_NAME_MAX) { - errno = ENAMETOOLONG; - return -1; - } - } - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } + int ret = 0; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + loc_t loc = { + 0, + }; + + /* validate in args */ + if ((fs == NULL) || (object == NULL)) { + errno = EINVAL; + return -1; + } - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, object); - if (!inode) { - errno = ESTALE; - goto out; + if (!is_listxattr) { + if (!name || *name == '\0') { + errno = EINVAL; + return -1; } - /* populate loc */ - GLFS_LOC_FILL_INODE (inode, loc, out); - - ret = syncop_getxattr (subvol, &loc, xattr, name, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + if (strlen(name) > GF_XATTR_NAME_MAX) { + errno = ENAMETOOLONG; + return -1; + } + } + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, object); + if (!inode) { + errno = ESTALE; + goto out; + } + + /* populate loc */ + GLFS_LOC_FILL_INODE(inode, loc, out); + + ret = syncop_getxattr(subvol, &loc, xattr, name, NULL, NULL); + DECODE_SYNCOP_ERR(ret); out: - loc_wipe (&loc); + loc_wipe(&loc); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - return ret; + return ret; } - int -pub_glfs_h_getxattrs (struct glfs *fs, struct glfs_object *object, - const char *name, void *value, size_t size) +pub_glfs_h_getxattrs(struct glfs *fs, struct glfs_object *object, + const char *name, void *value, size_t size) { - int ret = -1; - dict_t *xattr = NULL; + int ret = -1; + dict_t *xattr = NULL; - /* validate in args */ - if ((fs == NULL) || (object == NULL)) { - errno = EINVAL; - return -1; - } + /* validate in args */ + if ((fs == NULL) || (object == NULL)) { + errno = EINVAL; + return -1; + } - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - ret = glfs_h_getxattrs_common (fs, object, &xattr, name, - (name == NULL)); - if (ret) - goto out; + ret = glfs_h_getxattrs_common(fs, object, &xattr, name, (name == NULL)); + if (ret) + goto out; - /* If @name is NULL, means get all the xattrs (i.e listxattr). */ - if (name) - ret = glfs_getxattr_process (value, size, xattr, name); - else - ret = glfs_listxattr_process (value, size, xattr); + /* If @name is NULL, means get all the xattrs (i.e listxattr). */ + if (name) + ret = glfs_getxattr_process(value, size, xattr, name); + else + ret = glfs_listxattr_process(value, size, xattr); out: - if (xattr) - dict_unref (xattr); + if (xattr) + dict_unref(xattr); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_getxattrs, 3.5.1); int -pub_glfs_h_setattrs (struct glfs *fs, struct glfs_object *object, - struct stat *stat, int valid) +pub_glfs_h_setattrs(struct glfs *fs, struct glfs_object *object, + struct stat *stat, int valid) { - int ret = -1; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - int glvalid = 0; - - /* validate in args */ - if ((fs == NULL) || (object == NULL) || (stat == NULL)) { - errno = EINVAL; - return -1; - } - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, object); - if (!inode) { - errno = ESTALE; - goto out; - } - - /* map valid masks from in args */ - glfs_iatt_from_stat (stat, valid, &iatt, &glvalid); - - /* populate loc */ - GLFS_LOC_FILL_INODE (inode, loc, out); - - /* fop/op */ - ret = syncop_setattr (subvol, &loc, &iatt, glvalid, 0, 0, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + int ret = -1; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + int glvalid = 0; + + /* validate in args */ + if ((fs == NULL) || (object == NULL) || (stat == NULL)) { + errno = EINVAL; + return -1; + } + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, object); + if (!inode) { + errno = ESTALE; + goto out; + } + + /* map valid masks from in args */ + glfs_iatt_from_stat(stat, valid, &iatt, &glvalid); + + /* populate loc */ + GLFS_LOC_FILL_INODE(inode, loc, out); + + /* fop/op */ + ret = syncop_setattr(subvol, &loc, &iatt, glvalid, 0, 0, NULL, NULL); + DECODE_SYNCOP_ERR(ret); out: - loc_wipe (&loc); + loc_wipe(&loc); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_setattrs, 3.4.2); - int -pub_glfs_h_setxattrs (struct glfs *fs, struct glfs_object *object, - const char *name, const void *value, size_t size, - int flags) +pub_glfs_h_setxattrs(struct glfs *fs, struct glfs_object *object, + const char *name, const void *value, size_t size, + int flags) { - int ret = -1; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - loc_t loc = {0, }; - dict_t *xattr = NULL; - void *value_cp = NULL; - - /* validate in args */ - if ((fs == NULL) || (object == NULL) || - (name == NULL) || (value == NULL)) { - errno = EINVAL; - return -1; - } - - if (!name || *name == '\0') { - errno = EINVAL; - return -1; - } - - if (strlen(name) > GF_XATTR_NAME_MAX) { - errno = ENAMETOOLONG; - return -1; - } - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, object); - if (!inode) { - errno = ESTALE; - goto out; - } - - value_cp = gf_memdup (value, size); - GF_CHECK_ALLOC_AND_LOG (subvol->name, value_cp, ret, "Failed to" - " duplicate setxattr value", out); - - xattr = dict_for_key_value (name, value_cp, size, _gf_false); - if (!xattr) { - GF_FREE (value_cp); - ret = -1; - errno = ENOMEM; - goto out; - } + int ret = -1; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + loc_t loc = { + 0, + }; + dict_t *xattr = NULL; + void *value_cp = NULL; + + /* validate in args */ + if ((fs == NULL) || (object == NULL) || (name == NULL) || (value == NULL)) { + errno = EINVAL; + return -1; + } - /* populate loc */ - GLFS_LOC_FILL_INODE (inode, loc, out); + if (!name || *name == '\0') { + errno = EINVAL; + return -1; + } - /* fop/op */ - ret = syncop_setxattr (subvol, &loc, xattr, flags, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + if (strlen(name) > GF_XATTR_NAME_MAX) { + errno = ENAMETOOLONG; + return -1; + } + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, object); + if (!inode) { + errno = ESTALE; + goto out; + } + + value_cp = gf_memdup(value, size); + GF_CHECK_ALLOC_AND_LOG(subvol->name, value_cp, ret, + "Failed to" + " duplicate setxattr value", + out); + + xattr = dict_for_key_value(name, value_cp, size, _gf_false); + if (!xattr) { + GF_FREE(value_cp); + ret = -1; + errno = ENOMEM; + goto out; + } + + /* populate loc */ + GLFS_LOC_FILL_INODE(inode, loc, out); + + /* fop/op */ + ret = syncop_setxattr(subvol, &loc, xattr, flags, NULL, NULL); + DECODE_SYNCOP_ERR(ret); out: - loc_wipe (&loc); + loc_wipe(&loc); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - if (xattr) - dict_unref (xattr); + if (xattr) + dict_unref(xattr); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_setxattrs, 3.5.0); - int -pub_glfs_h_removexattrs (struct glfs *fs, struct glfs_object *object, - const char *name) +pub_glfs_h_removexattrs(struct glfs *fs, struct glfs_object *object, + const char *name) { - int ret = -1; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - loc_t loc = {0, }; - - /* validate in args */ - if ((fs == NULL) || (object == NULL) || (name == NULL)) { - errno = EINVAL; - return -1; - } + int ret = -1; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + loc_t loc = { + 0, + }; + + /* validate in args */ + if ((fs == NULL) || (object == NULL) || (name == NULL)) { + errno = EINVAL; + return -1; + } - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, object); - if (!inode) { - errno = ESTALE; - goto out; - } + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, object); + if (!inode) { + errno = ESTALE; + goto out; + } - /* populate loc */ - GLFS_LOC_FILL_INODE (inode, loc, out); + /* populate loc */ + GLFS_LOC_FILL_INODE(inode, loc, out); - /* fop/op */ - ret = syncop_removexattr (subvol, &loc, name, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + /* fop/op */ + ret = syncop_removexattr(subvol, &loc, name, NULL, NULL); + DECODE_SYNCOP_ERR(ret); out: - loc_wipe (&loc); + loc_wipe(&loc); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_removexattrs, 3.5.1); - struct glfs_fd * -pub_glfs_h_open (struct glfs *fs, struct glfs_object *object, int flags) +pub_glfs_h_open(struct glfs *fs, struct glfs_object *object, int flags) { - int ret = -1; - struct glfs_fd *glfd = NULL; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - loc_t loc = {0, }; - dict_t *fop_attr = NULL; - - /* validate in args */ - if ((fs == NULL) || (object == NULL)) { - errno = EINVAL; - return NULL; - } - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - errno = EIO; - goto out; - } - - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, object); - if (!inode) { - errno = ESTALE; - goto out; - } - - /* check types to open */ - if (IA_ISDIR (inode->ia_type)) { - ret = -1; - errno = EISDIR; - goto out; - } - - if (!IA_ISREG (inode->ia_type)) { - ret = -1; - errno = EINVAL; - goto out; - } - - glfd = glfs_fd_new (fs); - if (!glfd) { - ret = -1; - errno = ENOMEM; - goto out; - } - - glfd->fd = fd_create (inode, getpid()); - if (!glfd->fd) { - ret = -1; - errno = ENOMEM; - goto out; - } - glfd->fd->flags = flags; - - /* populate loc */ - GLFS_LOC_FILL_INODE (inode, loc, out); - - /* fop/op */ - ret = get_fop_attr_thrd_key (&fop_attr); - if (ret) - gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed"); + int ret = -1; + struct glfs_fd *glfd = NULL; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + loc_t loc = { + 0, + }; + dict_t *fop_attr = NULL; + + /* validate in args */ + if ((fs == NULL) || (object == NULL)) { + errno = EINVAL; + return NULL; + } + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + errno = EIO; + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, object); + if (!inode) { + errno = ESTALE; + goto out; + } + + /* check types to open */ + if (IA_ISDIR(inode->ia_type)) { + ret = -1; + errno = EISDIR; + goto out; + } + + if (!IA_ISREG(inode->ia_type)) { + ret = -1; + errno = EINVAL; + goto out; + } + + glfd = glfs_fd_new(fs); + if (!glfd) { + ret = -1; + errno = ENOMEM; + goto out; + } + + glfd->fd = fd_create(inode, getpid()); + if (!glfd->fd) { + ret = -1; + errno = ENOMEM; + goto out; + } + glfd->fd->flags = flags; + + /* populate loc */ + GLFS_LOC_FILL_INODE(inode, loc, out); + + /* fop/op */ + ret = get_fop_attr_thrd_key(&fop_attr); + if (ret) + gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed"); + + ret = syncop_open(subvol, &loc, flags, glfd->fd, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + + glfd->fd->flags = flags; - ret = syncop_open (subvol, &loc, flags, glfd->fd, NULL, NULL); - DECODE_SYNCOP_ERR (ret); +out: + loc_wipe(&loc); - glfd->fd->flags = flags; + if (inode) + inode_unref(inode); + if (fop_attr) + dict_unref(fop_attr); -out: - loc_wipe (&loc); - - if (inode) - inode_unref (inode); - if (fop_attr) - dict_unref (fop_attr); - - if (ret && glfd) { - GF_REF_PUT (glfd); - glfd = NULL; - } else if (glfd) { - glfd_set_state_bind (glfd); - } + if (ret && glfd) { + GF_REF_PUT(glfd); + glfd = NULL; + } else if (glfd) { + glfd_set_state_bind(glfd); + } - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return glfd; + return glfd; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_open, 3.4.2); - struct glfs_object * -pub_glfs_h_creat (struct glfs *fs, struct glfs_object *parent, const char *path, - int flags, mode_t mode, struct stat *stat) +pub_glfs_h_creat(struct glfs *fs, struct glfs_object *parent, const char *path, + int flags, mode_t mode, struct stat *stat) { - int ret = -1; - fd_t *fd = NULL; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - uuid_t gfid; - dict_t *xattr_req = NULL; - struct glfs_object *object = NULL; - - /* validate in args */ - if ((fs == NULL) || (parent == NULL) || (path == NULL)) { - errno = EINVAL; - return NULL; - } - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, parent); - if (!inode) { - ret = -1; - errno = ESTALE; - goto out; - } - - xattr_req = dict_new (); - if (!xattr_req) { - ret = -1; - errno = ENOMEM; - goto out; - } - - gf_uuid_generate (gfid); - ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true); - if (ret) { - ret = -1; - errno = ENOMEM; - goto out; - } - - GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, path); - - fd = fd_create (loc.inode, getpid()); - if (!fd) { - ret = -1; - errno = ENOMEM; - goto out; + int ret = -1; + fd_t *fd = NULL; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + uuid_t gfid; + dict_t *xattr_req = NULL; + struct glfs_object *object = NULL; + + /* validate in args */ + if ((fs == NULL) || (parent == NULL) || (path == NULL)) { + errno = EINVAL; + return NULL; + } + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, parent); + if (!inode) { + ret = -1; + errno = ESTALE; + goto out; + } + + xattr_req = dict_new(); + if (!xattr_req) { + ret = -1; + errno = ENOMEM; + goto out; + } + + gf_uuid_generate(gfid); + ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true); + if (ret) { + ret = -1; + errno = ENOMEM; + goto out; + } + + GLFS_LOC_FILL_PINODE(inode, loc, ret, errno, out, path); + + fd = fd_create(loc.inode, getpid()); + if (!fd) { + ret = -1; + errno = ENOMEM; + goto out; + } + fd->flags = flags; + + /* fop/op */ + ret = syncop_create(subvol, &loc, flags, mode, fd, &iatt, xattr_req, NULL); + DECODE_SYNCOP_ERR(ret); + + /* populate out args */ + if (ret == 0) { + ret = glfs_loc_link(&loc, &iatt); + if (ret != 0) { + goto out; } - fd->flags = flags; - - /* fop/op */ - ret = syncop_create (subvol, &loc, flags, mode, fd, &iatt, - xattr_req, NULL); - DECODE_SYNCOP_ERR (ret); - - /* populate out args */ - if (ret == 0) { - ret = glfs_loc_link (&loc, &iatt); - if (ret != 0) { - goto out; - } - if (stat) - glfs_iatt_to_stat (fs, &iatt, stat); + if (stat) + glfs_iatt_to_stat(fs, &iatt, stat); - ret = glfs_create_object (&loc, &object); - } + ret = glfs_create_object(&loc, &object); + } out: - if (ret && object != NULL) { - /* Release the held reference */ - glfs_h_close (object); - object = NULL; - } + if (ret && object != NULL) { + /* Release the held reference */ + glfs_h_close(object); + object = NULL; + } - loc_wipe(&loc); + loc_wipe(&loc); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - if (xattr_req) - dict_unref (xattr_req); + if (xattr_req) + dict_unref(xattr_req); - if (fd) - fd_unref(fd); + if (fd) + fd_unref(fd); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return object; + return object; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_creat, 3.4.2); - struct glfs_object * -pub_glfs_h_mkdir (struct glfs *fs, struct glfs_object *parent, const char *path, - mode_t mode, struct stat *stat) +pub_glfs_h_mkdir(struct glfs *fs, struct glfs_object *parent, const char *path, + mode_t mode, struct stat *stat) { - int ret = -1; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - uuid_t gfid; - dict_t *xattr_req = NULL; - struct glfs_object *object = NULL; - - /* validate in args */ - if ((fs == NULL) || (parent == NULL) || (path == NULL)) { - errno = EINVAL; - return NULL; - } - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, parent); - if (!inode) { - errno = ESTALE; - goto out; - } - - xattr_req = dict_new (); - if (!xattr_req) { - ret = -1; - errno = ENOMEM; - goto out; - } - - gf_uuid_generate (gfid); - ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true); - if (ret) { - ret = -1; - errno = ENOMEM; - goto out; + int ret = -1; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + uuid_t gfid; + dict_t *xattr_req = NULL; + struct glfs_object *object = NULL; + + /* validate in args */ + if ((fs == NULL) || (parent == NULL) || (path == NULL)) { + errno = EINVAL; + return NULL; + } + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, parent); + if (!inode) { + errno = ESTALE; + goto out; + } + + xattr_req = dict_new(); + if (!xattr_req) { + ret = -1; + errno = ENOMEM; + goto out; + } + + gf_uuid_generate(gfid); + ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true); + if (ret) { + ret = -1; + errno = ENOMEM; + goto out; + } + + GLFS_LOC_FILL_PINODE(inode, loc, ret, errno, out, path); + + /* fop/op */ + ret = syncop_mkdir(subvol, &loc, mode, &iatt, xattr_req, NULL); + DECODE_SYNCOP_ERR(ret); + + /* populate out args */ + if (ret == 0) { + ret = glfs_loc_link(&loc, &iatt); + if (ret != 0) { + goto out; } - GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, path); - - /* fop/op */ - ret = syncop_mkdir (subvol, &loc, mode, &iatt, xattr_req, NULL); - DECODE_SYNCOP_ERR (ret); - - /* populate out args */ - if ( ret == 0 ) { - ret = glfs_loc_link (&loc, &iatt); - if (ret != 0) { - goto out; - } + if (stat) + glfs_iatt_to_stat(fs, &iatt, stat); - if (stat) - glfs_iatt_to_stat (fs, &iatt, stat); - - ret = glfs_create_object (&loc, &object); - } + ret = glfs_create_object(&loc, &object); + } out: - if (ret && object != NULL) { - glfs_h_close (object); - object = NULL; - } + if (ret && object != NULL) { + glfs_h_close(object); + object = NULL; + } - loc_wipe(&loc); + loc_wipe(&loc); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - if (xattr_req) - dict_unref (xattr_req); + if (xattr_req) + dict_unref(xattr_req); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return object; + return object; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_mkdir, 3.4.2); - struct glfs_object * -pub_glfs_h_mknod (struct glfs *fs, struct glfs_object *parent, const char *path, - mode_t mode, dev_t dev, struct stat *stat) +pub_glfs_h_mknod(struct glfs *fs, struct glfs_object *parent, const char *path, + mode_t mode, dev_t dev, struct stat *stat) { - int ret = -1; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - uuid_t gfid; - dict_t *xattr_req = NULL; - struct glfs_object *object = NULL; - - /* validate in args */ - if ((fs == NULL) || (parent == NULL) || (path == NULL)) { - errno = EINVAL; - return NULL; - } - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, parent); - if (!inode) { - errno = ESTALE; - goto out; - } - - xattr_req = dict_new (); - if (!xattr_req) { - ret = -1; - errno = ENOMEM; - goto out; - } - - gf_uuid_generate (gfid); - ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true); - if (ret) { - ret = -1; - errno = ENOMEM; - goto out; + int ret = -1; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + uuid_t gfid; + dict_t *xattr_req = NULL; + struct glfs_object *object = NULL; + + /* validate in args */ + if ((fs == NULL) || (parent == NULL) || (path == NULL)) { + errno = EINVAL; + return NULL; + } + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, parent); + if (!inode) { + errno = ESTALE; + goto out; + } + + xattr_req = dict_new(); + if (!xattr_req) { + ret = -1; + errno = ENOMEM; + goto out; + } + + gf_uuid_generate(gfid); + ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true); + if (ret) { + ret = -1; + errno = ENOMEM; + goto out; + } + + GLFS_LOC_FILL_PINODE(inode, loc, ret, errno, out, path); + + /* fop/op */ + ret = syncop_mknod(subvol, &loc, mode, dev, &iatt, xattr_req, NULL); + DECODE_SYNCOP_ERR(ret); + + /* populate out args */ + if (ret == 0) { + ret = glfs_loc_link(&loc, &iatt); + if (ret != 0) { + goto out; } - GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, path); - - /* fop/op */ - ret = syncop_mknod (subvol, &loc, mode, dev, &iatt, xattr_req, NULL); - DECODE_SYNCOP_ERR (ret); - - /* populate out args */ - if (ret == 0) { - ret = glfs_loc_link (&loc, &iatt); - if (ret != 0) { - goto out; - } - - if (stat) - glfs_iatt_to_stat (fs, &iatt, stat); + if (stat) + glfs_iatt_to_stat(fs, &iatt, stat); - ret = glfs_create_object (&loc, &object); - } + ret = glfs_create_object(&loc, &object); + } out: - if (ret && object != NULL) { - glfs_h_close (object); - object = NULL; - } + if (ret && object != NULL) { + glfs_h_close(object); + object = NULL; + } - loc_wipe(&loc); + loc_wipe(&loc); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - if (xattr_req) - dict_unref (xattr_req); + if (xattr_req) + dict_unref(xattr_req); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return object; + return object; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_mknod, 3.4.2); - int -pub_glfs_h_unlink (struct glfs *fs, struct glfs_object *parent, const char *path) +pub_glfs_h_unlink(struct glfs *fs, struct glfs_object *parent, const char *path) { - int ret = -1; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - loc_t loc = {0, }; - - /* validate in args */ - if ((fs == NULL) || (parent == NULL) || (path == NULL)) { - errno = EINVAL; - return -1; - } - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if ( !subvol ) { - ret = -1; - errno = EIO; - goto out; - } - - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, parent); - if (!inode) { - errno = ESTALE; - goto out; - } - - ret = glfs_resolve_at (fs, subvol, inode, path, &loc, NULL, 0 , 0); + int ret = -1; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + loc_t loc = { + 0, + }; + + /* validate in args */ + if ((fs == NULL) || (parent == NULL) || (path == NULL)) { + errno = EINVAL; + return -1; + } + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, parent); + if (!inode) { + errno = ESTALE; + goto out; + } + + ret = glfs_resolve_at(fs, subvol, inode, path, &loc, NULL, 0, 0); + if (ret != 0) { + goto out; + } + + if (!IA_ISDIR(loc.inode->ia_type)) { + ret = syncop_unlink(subvol, &loc, NULL, NULL); + DECODE_SYNCOP_ERR(ret); if (ret != 0) { - goto out; + goto out; } - - if (!IA_ISDIR(loc.inode->ia_type)) { - ret = syncop_unlink (subvol, &loc, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - if (ret != 0) { - goto out; - } - } else { - ret = syncop_rmdir (subvol, &loc, 0, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - if (ret != 0) { - goto out; - } + } else { + ret = syncop_rmdir(subvol, &loc, 0, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + if (ret != 0) { + goto out; } + } - if (ret == 0) - ret = glfs_loc_unlink (&loc); + if (ret == 0) + ret = glfs_loc_unlink(&loc); out: - loc_wipe (&loc); - - if (inode) - inode_unref (inode); - - glfs_subvol_done (fs, subvol); - - __GLFS_EXIT_FS; + loc_wipe(&loc); -invalid_fs: - return ret; -} - -GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_unlink, 3.4.2); - - -struct glfs_fd * -pub_glfs_h_opendir (struct glfs *fs, struct glfs_object *object) -{ - int ret = -1; - struct glfs_fd *glfd = NULL; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - loc_t loc = {0, }; - - /* validate in args */ - if ((fs == NULL) || (object == NULL)) { - errno = EINVAL; - return NULL; - } + if (inode) + inode_unref(inode); - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + glfs_subvol_done(fs, subvol); - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, object); - if (!inode) { - errno = ESTALE; - goto out; - } - - if (!IA_ISDIR (inode->ia_type)) { - ret = -1; - errno = ENOTDIR; - goto out; - } - - glfd = glfs_fd_new (fs); - if (!glfd) - goto out; - - INIT_LIST_HEAD (&glfd->entries); - - glfd->fd = fd_create (inode, getpid()); - if (!glfd->fd) { - ret = -1; - errno = ENOMEM; - goto out; - } + __GLFS_EXIT_FS; - GLFS_LOC_FILL_INODE (inode, loc, out); +invalid_fs: + return ret; +} + +GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_unlink, 3.4.2); - /* fop/op */ - ret = syncop_opendir (subvol, &loc, glfd->fd, NULL, NULL); - DECODE_SYNCOP_ERR (ret); +struct glfs_fd * +pub_glfs_h_opendir(struct glfs *fs, struct glfs_object *object) +{ + int ret = -1; + struct glfs_fd *glfd = NULL; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + loc_t loc = { + 0, + }; + + /* validate in args */ + if ((fs == NULL) || (object == NULL)) { + errno = EINVAL; + return NULL; + } + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, object); + if (!inode) { + errno = ESTALE; + goto out; + } + + if (!IA_ISDIR(inode->ia_type)) { + ret = -1; + errno = ENOTDIR; + goto out; + } + + glfd = glfs_fd_new(fs); + if (!glfd) + goto out; + + INIT_LIST_HEAD(&glfd->entries); + + glfd->fd = fd_create(inode, getpid()); + if (!glfd->fd) { + ret = -1; + errno = ENOMEM; + goto out; + } + + GLFS_LOC_FILL_INODE(inode, loc, out); + + /* fop/op */ + ret = syncop_opendir(subvol, &loc, glfd->fd, NULL, NULL); + DECODE_SYNCOP_ERR(ret); out: - loc_wipe (&loc); + loc_wipe(&loc); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - if (ret && glfd) { - GF_REF_PUT (glfd); - glfd = NULL; - } else if (glfd) { - glfd_set_state_bind (glfd); - } + if (ret && glfd) { + GF_REF_PUT(glfd); + glfd = NULL; + } else if (glfd) { + glfd_set_state_bind(glfd); + } - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return glfd; + return glfd; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_opendir, 3.4.2); - int -pub_glfs_h_access (struct glfs *fs, struct glfs_object *object, int mask) +pub_glfs_h_access(struct glfs *fs, struct glfs_object *object, int mask) { - int ret = -1; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - loc_t loc = {0, }; - - DECLARE_OLD_THIS; - - /* validate in args */ - if ((fs == NULL) || (object == NULL)) { - errno = EINVAL; - return ret; - } - - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + int ret = -1; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + loc_t loc = { + 0, + }; + + DECLARE_OLD_THIS; + + /* validate in args */ + if ((fs == NULL) || (object == NULL)) { + errno = EINVAL; + return ret; + } - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, object); - if (!inode) { - errno = ESTALE; - goto out; - } + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, object); + if (!inode) { + errno = ESTALE; + goto out; + } - GLFS_LOC_FILL_INODE (inode, loc, out); + GLFS_LOC_FILL_INODE(inode, loc, out); - /* fop/op */ + /* fop/op */ - ret = syncop_access (subvol, &loc, mask, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + ret = syncop_access(subvol, &loc, mask, NULL, NULL); + DECODE_SYNCOP_ERR(ret); out: - loc_wipe (&loc); - - if (inode) - inode_unref (inode); + loc_wipe(&loc); + if (inode) + inode_unref(inode); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_access, 3.6.0); - ssize_t -pub_glfs_h_extract_handle (struct glfs_object *object, unsigned char *handle, - int len) +pub_glfs_h_extract_handle(struct glfs_object *object, unsigned char *handle, + int len) { - ssize_t ret = -1; + ssize_t ret = -1; - /* validate in args */ - if (object == NULL) { - errno = EINVAL; - goto out; - } + /* validate in args */ + if (object == NULL) { + errno = EINVAL; + goto out; + } - if (!handle || !len) { - ret = GFAPI_HANDLE_LENGTH; - goto out; - } + if (!handle || !len) { + ret = GFAPI_HANDLE_LENGTH; + goto out; + } - if (len < GFAPI_HANDLE_LENGTH) - { - errno = ERANGE; - goto out; - } + if (len < GFAPI_HANDLE_LENGTH) { + errno = ERANGE; + goto out; + } - memcpy (handle, object->gfid, GFAPI_HANDLE_LENGTH); + memcpy(handle, object->gfid, GFAPI_HANDLE_LENGTH); - ret = GFAPI_HANDLE_LENGTH; + ret = GFAPI_HANDLE_LENGTH; out: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_extract_handle, 3.4.2); - struct glfs_object * -pub_glfs_h_create_from_handle (struct glfs *fs, unsigned char *handle, int len, - struct stat *stat) +pub_glfs_h_create_from_handle(struct glfs *fs, unsigned char *handle, int len, + struct stat *stat) { - loc_t loc = {0, }; - int ret = -1; - struct iatt iatt = {0, }; - inode_t *newinode = NULL; - xlator_t *subvol = NULL; - struct glfs_object *object = NULL; - uint64_t ctx_value = LOOKUP_NOT_NEEDED; - gf_boolean_t lookup_needed = _gf_false; - - /* validate in args */ - if ((fs == NULL) || (handle == NULL) || (len != GFAPI_HANDLE_LENGTH)) { - errno = EINVAL; - return NULL; - } + loc_t loc = { + 0, + }; + int ret = -1; + struct iatt iatt = { + 0, + }; + inode_t *newinode = NULL; + xlator_t *subvol = NULL; + struct glfs_object *object = NULL; + uint64_t ctx_value = LOOKUP_NOT_NEEDED; + gf_boolean_t lookup_needed = _gf_false; + + /* validate in args */ + if ((fs == NULL) || (handle == NULL) || (len != GFAPI_HANDLE_LENGTH)) { + errno = EINVAL; + return NULL; + } - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - errno = EIO; - goto out; - } + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + errno = EIO; + goto out; + } - memcpy (loc.gfid, handle, GFAPI_HANDLE_LENGTH); - - /* make sure the gfid received is valid */ - GF_VALIDATE_OR_GOTO ("glfs_h_create_from_handle", - !(gf_uuid_is_null (loc.gfid)), out); - - newinode = inode_find (subvol->itable, loc.gfid); - if (newinode) { - if (!stat) /* No need of lookup */ - goto found; - - lookup_needed = inode_needs_lookup (newinode, THIS); - if (lookup_needed) { - loc.inode = newinode; - } else { - /* populate loc */ - GLFS_LOC_FILL_INODE (newinode, loc, fill_out); - - /* fop/op */ - ret = syncop_stat (subvol, &loc, &iatt, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - - if (ret) { -fill_out: - /* Drop the reference hold in inode_find */ - inode_unref (newinode); - goto out; - } - - glfs_iatt_to_stat (fs, &iatt, stat); - goto found; - } - } else { - loc.inode = inode_new (subvol->itable); - if (!loc.inode) { - errno = ENOMEM; - goto out; - } - } + memcpy(loc.gfid, handle, GFAPI_HANDLE_LENGTH); - ret = syncop_lookup (subvol, &loc, &iatt, 0, 0, 0); - DECODE_SYNCOP_ERR (ret); - if (ret) { - gf_msg (subvol->name, GF_LOG_WARNING, errno, - API_MSG_INODE_REFRESH_FAILED, - "inode refresh of %s failed: %s", - uuid_utoa (loc.gfid), strerror (errno)); - goto out; - } + /* make sure the gfid received is valid */ + GF_VALIDATE_OR_GOTO("glfs_h_create_from_handle", + !(gf_uuid_is_null(loc.gfid)), out); - newinode = inode_link (loc.inode, 0, 0, &iatt); - if (newinode) { - if (newinode == loc.inode) { - inode_ctx_set (newinode, THIS, &ctx_value); - } - inode_lookup (newinode); - } else { - gf_msg (subvol->name, GF_LOG_WARNING, errno, - API_MSG_INODE_LINK_FAILED, - "inode linking of %s failed", uuid_utoa (loc.gfid)); - goto out; - } + newinode = inode_find(subvol->itable, loc.gfid); + if (newinode) { + if (!stat) /* No need of lookup */ + goto found; - /* populate stat */ - if (stat) - glfs_iatt_to_stat (fs, &iatt, stat); + lookup_needed = inode_needs_lookup(newinode, THIS); + if (lookup_needed) { + loc.inode = newinode; + } else { + /* populate loc */ + GLFS_LOC_FILL_INODE(newinode, loc, fill_out); + + /* fop/op */ + ret = syncop_stat(subvol, &loc, &iatt, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + + if (ret) { + fill_out: + /* Drop the reference hold in inode_find */ + inode_unref(newinode); + goto out; + } + + glfs_iatt_to_stat(fs, &iatt, stat); + goto found; + } + } else { + loc.inode = inode_new(subvol->itable); + if (!loc.inode) { + errno = ENOMEM; + goto out; + } + } + + ret = syncop_lookup(subvol, &loc, &iatt, 0, 0, 0); + DECODE_SYNCOP_ERR(ret); + if (ret) { + gf_msg(subvol->name, GF_LOG_WARNING, errno, + API_MSG_INODE_REFRESH_FAILED, "inode refresh of %s failed: %s", + uuid_utoa(loc.gfid), strerror(errno)); + goto out; + } + + newinode = inode_link(loc.inode, 0, 0, &iatt); + if (newinode) { + if (newinode == loc.inode) { + inode_ctx_set(newinode, THIS, &ctx_value); + } + inode_lookup(newinode); + } else { + gf_msg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED, + "inode linking of %s failed", uuid_utoa(loc.gfid)); + goto out; + } + + /* populate stat */ + if (stat) + glfs_iatt_to_stat(fs, &iatt, stat); found: - object = GF_CALLOC (1, sizeof(struct glfs_object), - glfs_mt_glfs_object_t); - if (object == NULL) { - errno = ENOMEM; - ret = -1; - goto out; - } + object = GF_CALLOC(1, sizeof(struct glfs_object), glfs_mt_glfs_object_t); + if (object == NULL) { + errno = ENOMEM; + ret = -1; + goto out; + } - /* populate the return object */ - object->inode = newinode; - gf_uuid_copy (object->gfid, object->inode->gfid); + /* populate the return object */ + object->inode = newinode; + gf_uuid_copy(object->gfid, object->inode->gfid); out: - /* TODO: Check where the inode ref is being held? */ - loc_wipe (&loc); + /* TODO: Check where the inode ref is being held? */ + loc_wipe(&loc); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return object; + return object; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_create_from_handle, 3.4.2); - int -pub_glfs_h_close (struct glfs_object *object) +pub_glfs_h_close(struct glfs_object *object) { - /* since glfs_h_* objects hold a reference to inode - * it is safe to keep lookup count to '0' */ - inode_forget (object->inode, 0); - inode_unref (object->inode); - GF_FREE (object); + /* since glfs_h_* objects hold a reference to inode + * it is safe to keep lookup count to '0' */ + inode_forget(object->inode, 0); + inode_unref(object->inode); + GF_FREE(object); - return 0; + return 0; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_close, 3.4.2); - int -pub_glfs_h_truncate (struct glfs *fs, struct glfs_object *object, off_t offset) +pub_glfs_h_truncate(struct glfs *fs, struct glfs_object *object, off_t offset) { - loc_t loc = {0, }; - int ret = -1; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - - DECLARE_OLD_THIS; - - /* validate in args */ - if (object == NULL) { - errno = EINVAL; - return -1; - } + loc_t loc = { + 0, + }; + int ret = -1; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + + DECLARE_OLD_THIS; + + /* validate in args */ + if (object == NULL) { + errno = EINVAL; + return -1; + } - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, object); - if (!inode) { - errno = ESTALE; - goto out; - } + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, object); + if (!inode) { + errno = ESTALE; + goto out; + } - GLFS_LOC_FILL_INODE (inode, loc, out); + GLFS_LOC_FILL_INODE(inode, loc, out); - /* fop/op */ - ret = syncop_truncate (subvol, &loc, (off_t)offset, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + /* fop/op */ + ret = syncop_truncate(subvol, &loc, (off_t)offset, NULL, NULL); + DECODE_SYNCOP_ERR(ret); - /* populate out args */ - if (ret == 0) - ret = glfs_loc_unlink (&loc); + /* populate out args */ + if (ret == 0) + ret = glfs_loc_unlink(&loc); out: - loc_wipe (&loc); + loc_wipe(&loc); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_truncate, 3.4.2); - struct glfs_object * -pub_glfs_h_symlink (struct glfs *fs, struct glfs_object *parent, - const char *name, const char *data, struct stat *stat) +pub_glfs_h_symlink(struct glfs *fs, struct glfs_object *parent, + const char *name, const char *data, struct stat *stat) { - int ret = -1; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - loc_t loc = {0, }; - struct iatt iatt = {0, }; - uuid_t gfid; - dict_t *xattr_req = NULL; - struct glfs_object *object = NULL; - - DECLARE_OLD_THIS; - - /* validate in args */ - if ((parent == NULL) || (name == NULL) || - (data == NULL)) { - errno = EINVAL; - return NULL; - } - - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, parent); - if (!inode) { - errno = ESTALE; - goto out; - } - - xattr_req = dict_new (); - if (!xattr_req) { - ret = -1; - errno = ENOMEM; - goto out; - } - - gf_uuid_generate (gfid); - ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true); - if (ret) { - ret = -1; - errno = ENOMEM; - goto out; + int ret = -1; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + loc_t loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + uuid_t gfid; + dict_t *xattr_req = NULL; + struct glfs_object *object = NULL; + + DECLARE_OLD_THIS; + + /* validate in args */ + if ((parent == NULL) || (name == NULL) || (data == NULL)) { + errno = EINVAL; + return NULL; + } + + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, parent); + if (!inode) { + errno = ESTALE; + goto out; + } + + xattr_req = dict_new(); + if (!xattr_req) { + ret = -1; + errno = ENOMEM; + goto out; + } + + gf_uuid_generate(gfid); + ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true); + if (ret) { + ret = -1; + errno = ENOMEM; + goto out; + } + + GLFS_LOC_FILL_PINODE(inode, loc, ret, errno, out, name); + + /* fop/op */ + ret = syncop_symlink(subvol, &loc, data, &iatt, xattr_req, NULL); + DECODE_SYNCOP_ERR(ret); + + /* populate out args */ + if (ret == 0) { + ret = glfs_loc_link(&loc, &iatt); + if (ret != 0) { + goto out; } - GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, name); - - /* fop/op */ - ret = syncop_symlink (subvol, &loc, data, &iatt, xattr_req, NULL); - DECODE_SYNCOP_ERR (ret); - - /* populate out args */ - if (ret == 0) { - ret = glfs_loc_link (&loc, &iatt); - if (ret != 0) { - goto out; - } - - if (stat) - glfs_iatt_to_stat (fs, &iatt, stat); + if (stat) + glfs_iatt_to_stat(fs, &iatt, stat); - ret = glfs_create_object (&loc, &object); - } + ret = glfs_create_object(&loc, &object); + } out: - if (ret && object != NULL) { - pub_glfs_h_close (object); - object = NULL; - } + if (ret && object != NULL) { + pub_glfs_h_close(object); + object = NULL; + } - loc_wipe(&loc); + loc_wipe(&loc); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - if (xattr_req) - dict_unref (xattr_req); + if (xattr_req) + dict_unref(xattr_req); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return object; + return object; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_symlink, 3.4.2); - int -pub_glfs_h_readlink (struct glfs *fs, struct glfs_object *object, char *buf, - size_t bufsiz) +pub_glfs_h_readlink(struct glfs *fs, struct glfs_object *object, char *buf, + size_t bufsiz) { - loc_t loc = {0, }; - int ret = -1; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - char *linkval = NULL; - - DECLARE_OLD_THIS; - - /* validate in args */ - if ((object == NULL) || (buf == NULL)) { - errno = EINVAL; - return -1; - } + loc_t loc = { + 0, + }; + int ret = -1; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + char *linkval = NULL; + + DECLARE_OLD_THIS; + + /* validate in args */ + if ((object == NULL) || (buf == NULL)) { + errno = EINVAL; + return -1; + } - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, object); - if (!inode) { - errno = ESTALE; - goto out; - } + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, object); + if (!inode) { + errno = ESTALE; + goto out; + } - GLFS_LOC_FILL_INODE (inode, loc, out); + GLFS_LOC_FILL_INODE(inode, loc, out); - /* fop/op */ - ret = syncop_readlink (subvol, &loc, &linkval, bufsiz, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + /* fop/op */ + ret = syncop_readlink(subvol, &loc, &linkval, bufsiz, NULL, NULL); + DECODE_SYNCOP_ERR(ret); - /* populate out args */ - if (ret > 0) - memcpy (buf, linkval, ret); + /* populate out args */ + if (ret > 0) + memcpy(buf, linkval, ret); out: - loc_wipe (&loc); + loc_wipe(&loc); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - if (linkval) - GF_FREE (linkval); + if (linkval) + GF_FREE(linkval); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_readlink, 3.4.2); - int -pub_glfs_h_link (struct glfs *fs, struct glfs_object *linksrc, - struct glfs_object *parent, const char *name) +pub_glfs_h_link(struct glfs *fs, struct glfs_object *linksrc, + struct glfs_object *parent, const char *name) { - int ret = -1; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - inode_t *pinode = NULL; - loc_t oldloc = {0, }; - loc_t newloc = {0, }; - struct iatt iatt = {0, }; - - DECLARE_OLD_THIS; - - /* validate in args */ - if ((linksrc == NULL) || (parent == NULL) || - (name == NULL)) { - errno = EINVAL; - return -1; - } - - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, linksrc); - if (!inode) { - errno = ESTALE; - goto out; - } - - if (inode->ia_type == IA_IFDIR) { - ret = -1; - errno = EISDIR; - goto out; - } - - GLFS_LOC_FILL_INODE (inode, oldloc, out); - - /* get/refresh the in arg objects inode in correlation to the xlator */ - pinode = glfs_resolve_inode (fs, subvol, parent); - if (!pinode) { - errno = ESTALE; - goto out; - } - - /* setup newloc based on parent */ - newloc.parent = inode_ref (pinode); - newloc.name = name; - ret = glfs_loc_touchup (&newloc); - if (ret != 0) { - errno = EINVAL; - goto out; - } - - /* Filling the inode of the hard link to be same as that of the - * original file - */ - newloc.inode = inode_ref (inode); - - /* fop/op */ - ret = syncop_link (subvol, &oldloc, &newloc, &iatt, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - - if (ret == 0) - ret = glfs_loc_link (&newloc, &iatt); + int ret = -1; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + inode_t *pinode = NULL; + loc_t oldloc = { + 0, + }; + loc_t newloc = { + 0, + }; + struct iatt iatt = { + 0, + }; + + DECLARE_OLD_THIS; + + /* validate in args */ + if ((linksrc == NULL) || (parent == NULL) || (name == NULL)) { + errno = EINVAL; + return -1; + } + + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, linksrc); + if (!inode) { + errno = ESTALE; + goto out; + } + + if (inode->ia_type == IA_IFDIR) { + ret = -1; + errno = EISDIR; + goto out; + } + + GLFS_LOC_FILL_INODE(inode, oldloc, out); + + /* get/refresh the in arg objects inode in correlation to the xlator */ + pinode = glfs_resolve_inode(fs, subvol, parent); + if (!pinode) { + errno = ESTALE; + goto out; + } + + /* setup newloc based on parent */ + newloc.parent = inode_ref(pinode); + newloc.name = name; + ret = glfs_loc_touchup(&newloc); + if (ret != 0) { + errno = EINVAL; + goto out; + } + + /* Filling the inode of the hard link to be same as that of the + * original file + */ + newloc.inode = inode_ref(inode); + + /* fop/op */ + ret = syncop_link(subvol, &oldloc, &newloc, &iatt, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + + if (ret == 0) + ret = glfs_loc_link(&newloc, &iatt); out: - loc_wipe (&oldloc); - loc_wipe (&newloc); + loc_wipe(&oldloc); + loc_wipe(&newloc); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - if (pinode) - inode_unref (pinode); + if (pinode) + inode_unref(pinode); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_link, 3.4.2); - int -pub_glfs_h_rename (struct glfs *fs, struct glfs_object *olddir, - const char *oldname, struct glfs_object *newdir, - const char *newname) +pub_glfs_h_rename(struct glfs *fs, struct glfs_object *olddir, + const char *oldname, struct glfs_object *newdir, + const char *newname) { - int ret = -1; - xlator_t *subvol = NULL; - inode_t *oldpinode = NULL; - inode_t *newpinode = NULL; - loc_t oldloc = {0, }; - loc_t newloc = {0, }; - struct iatt oldiatt = {0, }; - struct iatt newiatt = {0, }; - - DECLARE_OLD_THIS; - - /* validate in args */ - if ((olddir == NULL) || (oldname == NULL) || - (newdir == NULL) || (newname == NULL)) { - errno = EINVAL; - return -1; - } - - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if ( !subvol ) { - ret = -1; - errno = EIO; - goto out; - } - - /* get/refresh the in arg objects inode in correlation to the xlator */ - oldpinode = glfs_resolve_inode (fs, subvol, olddir); - if (!oldpinode) { - errno = ESTALE; - goto out; - } - - ret = glfs_resolve_at (fs, subvol, oldpinode, oldname, &oldloc, - &oldiatt, 0 , 0); - if (ret != 0) { - goto out; - } - - /* get/refresh the in arg objects inode in correlation to the xlator */ - newpinode = glfs_resolve_inode (fs, subvol, newdir); - if (!newpinode) { - errno = ESTALE; - goto out; - } - - ret = glfs_resolve_at (fs, subvol, newpinode, newname, &newloc, - &newiatt, 0, 0); - - if (ret && errno != ENOENT && newloc.parent) - goto out; - - if (newiatt.ia_type != IA_INVAL) { - if ((oldiatt.ia_type == IA_IFDIR) != - (newiatt.ia_type == IA_IFDIR)) { - /* Either both old and new must be dirs, - * or both must be non-dirs. Else, fail. - */ - ret = -1; - errno = EEXIST; - goto out; - } - } - - /* TODO: check if new or old is a prefix of the other, and fail EINVAL */ - - ret = syncop_rename (subvol, &oldloc, &newloc, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - - if (ret == 0) { - inode_rename (oldloc.parent->table, oldloc.parent, oldloc.name, - newloc.parent, newloc.name, oldloc.inode, - &oldiatt); - - if (newloc.inode && !inode_has_dentry (newloc.inode)) - inode_forget (newloc.inode, 0); - - } + int ret = -1; + xlator_t *subvol = NULL; + inode_t *oldpinode = NULL; + inode_t *newpinode = NULL; + loc_t oldloc = { + 0, + }; + loc_t newloc = { + 0, + }; + struct iatt oldiatt = { + 0, + }; + struct iatt newiatt = { + 0, + }; + + DECLARE_OLD_THIS; + + /* validate in args */ + if ((olddir == NULL) || (oldname == NULL) || (newdir == NULL) || + (newname == NULL)) { + errno = EINVAL; + return -1; + } + + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + oldpinode = glfs_resolve_inode(fs, subvol, olddir); + if (!oldpinode) { + errno = ESTALE; + goto out; + } + + ret = glfs_resolve_at(fs, subvol, oldpinode, oldname, &oldloc, &oldiatt, 0, + 0); + if (ret != 0) { + goto out; + } + + /* get/refresh the in arg objects inode in correlation to the xlator */ + newpinode = glfs_resolve_inode(fs, subvol, newdir); + if (!newpinode) { + errno = ESTALE; + goto out; + } + + ret = glfs_resolve_at(fs, subvol, newpinode, newname, &newloc, &newiatt, 0, + 0); + + if (ret && errno != ENOENT && newloc.parent) + goto out; + + if (newiatt.ia_type != IA_INVAL) { + if ((oldiatt.ia_type == IA_IFDIR) != (newiatt.ia_type == IA_IFDIR)) { + /* Either both old and new must be dirs, + * or both must be non-dirs. Else, fail. + */ + ret = -1; + errno = EEXIST; + goto out; + } + } + + /* TODO: check if new or old is a prefix of the other, and fail EINVAL */ + + ret = syncop_rename(subvol, &oldloc, &newloc, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + + if (ret == 0) { + inode_rename(oldloc.parent->table, oldloc.parent, oldloc.name, + newloc.parent, newloc.name, oldloc.inode, &oldiatt); + + if (newloc.inode && !inode_has_dentry(newloc.inode)) + inode_forget(newloc.inode, 0); + } out: - loc_wipe (&oldloc); - loc_wipe (&newloc); + loc_wipe(&oldloc); + loc_wipe(&newloc); - if (oldpinode) - inode_unref (oldpinode); + if (oldpinode) + inode_unref(oldpinode); - if (newpinode) - inode_unref (newpinode); + if (newpinode) + inode_unref(newpinode); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_rename, 3.4.2); @@ -1829,199 +1863,186 @@ GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_rename, 3.4.2); * the inode table. If yes create and return the corresponding glfs_object. */ struct glfs_object * -glfs_h_find_handle (struct glfs *fs, unsigned char *handle, int len) +glfs_h_find_handle(struct glfs *fs, unsigned char *handle, int len) { - inode_t *newinode = NULL; - xlator_t *subvol = NULL; - struct glfs_object *object = NULL; - uuid_t gfid; - - /* validate in args */ - if ((fs == NULL) || (handle == NULL) || (len != GFAPI_HANDLE_LENGTH)) { - errno = EINVAL; - return NULL; - } + inode_t *newinode = NULL; + xlator_t *subvol = NULL; + struct glfs_object *object = NULL; + uuid_t gfid; + + /* validate in args */ + if ((fs == NULL) || (handle == NULL) || (len != GFAPI_HANDLE_LENGTH)) { + errno = EINVAL; + return NULL; + } - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - errno = EIO; - goto out; - } + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + errno = EIO; + goto out; + } - memcpy (gfid, handle, GFAPI_HANDLE_LENGTH); + memcpy(gfid, handle, GFAPI_HANDLE_LENGTH); - /* make sure the gfid received is valid */ - GF_VALIDATE_OR_GOTO ("glfs_h_find_handle", - !(gf_uuid_is_null (gfid)), out); + /* make sure the gfid received is valid */ + GF_VALIDATE_OR_GOTO("glfs_h_find_handle", !(gf_uuid_is_null(gfid)), out); - newinode = inode_find (subvol->itable, gfid); - if (!newinode) { - goto out; - } + newinode = inode_find(subvol->itable, gfid); + if (!newinode) { + goto out; + } - object = GF_CALLOC (1, sizeof(struct glfs_object), - glfs_mt_glfs_object_t); - if (object == NULL) { - errno = ENOMEM; - goto out; - } + object = GF_CALLOC(1, sizeof(struct glfs_object), glfs_mt_glfs_object_t); + if (object == NULL) { + errno = ENOMEM; + goto out; + } - /* populate the return object. The ref taken here - * is un'refed when the application does glfs_h_close() */ - object->inode = inode_ref(newinode); - gf_uuid_copy (object->gfid, object->inode->gfid); + /* populate the return object. The ref taken here + * is un'refed when the application does glfs_h_close() */ + object->inode = inode_ref(newinode); + gf_uuid_copy(object->gfid, object->inode->gfid); out: - /* inode_find takes a reference. Unref it. */ - if (newinode) - inode_unref (newinode); + /* inode_find takes a reference. Unref it. */ + if (newinode) + inode_unref(newinode); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return object; - + return object; } static void -glfs_free_upcall_inode (void *to_free) +glfs_free_upcall_inode(void *to_free) { - struct glfs_upcall_inode *arg = to_free; + struct glfs_upcall_inode *arg = to_free; - if (!arg) - return; + if (!arg) + return; - if (arg->object) - glfs_h_close (arg->object); - if (arg->p_object) - glfs_h_close (arg->p_object); - if (arg->oldp_object) - glfs_h_close (arg->oldp_object); + if (arg->object) + glfs_h_close(arg->object); + if (arg->p_object) + glfs_h_close(arg->p_object); + if (arg->oldp_object) + glfs_h_close(arg->oldp_object); - GF_FREE (arg); + GF_FREE(arg); } int -glfs_h_poll_cache_invalidation (struct glfs *fs, - struct glfs_upcall *up_arg, - struct gf_upcall *upcall_data) +glfs_h_poll_cache_invalidation(struct glfs *fs, struct glfs_upcall *up_arg, + struct gf_upcall *upcall_data) { - int ret = -1; - struct glfs_object *p_object = NULL; - struct glfs_object *oldp_object = NULL; - struct glfs_object *object = NULL; - struct gf_upcall_cache_invalidation *ca_data = NULL; - struct glfs_upcall_inode *up_inode_arg = NULL; - - ca_data = upcall_data->data; - GF_VALIDATE_OR_GOTO ("glfs_h_poll_cache_invalidation", - ca_data, out); - - object = glfs_h_find_handle (fs, upcall_data->gfid, - GFAPI_HANDLE_LENGTH); - if (!object) { - /* The reason handle creation will fail is because we - * couldn't find the inode in the gfapi inode table. - * - * But since application would have taken inode_ref, the - * only case when this can happen is when it has closed - * the handle and hence will no more be interested in - * the upcall for this particular gfid. - */ - gf_msg (THIS->name, GF_LOG_DEBUG, errno, - API_MSG_CREATE_HANDLE_FAILED, - "handle creation of %s failed", - uuid_utoa (upcall_data->gfid)); - errno = ESTALE; - goto out; - } - - up_inode_arg = GF_CALLOC (1, sizeof (struct glfs_upcall_inode), - glfs_mt_upcall_inode_t); - GF_VALIDATE_OR_GOTO ("glfs_h_poll_cache_invalidation", - up_inode_arg, out); - - up_inode_arg->object = object; - up_inode_arg->flags = ca_data->flags; - up_inode_arg->expire_time_attr = ca_data->expire_time_attr; - - /* XXX: Update stat as well in case of UP_*_TIMES. - * This will be addressed as part of INODE_UPDATE */ - if (ca_data->flags & GFAPI_INODE_UPDATE_FLAGS) { - glfs_iatt_to_stat (fs, &ca_data->stat, &up_inode_arg->buf); - } - - if (ca_data->flags & GFAPI_UP_PARENT_TIMES) { - p_object = glfs_h_find_handle (fs, - ca_data->p_stat.ia_gfid, - GFAPI_HANDLE_LENGTH); - if (!p_object) { - gf_msg (THIS->name, GF_LOG_DEBUG, errno, - API_MSG_CREATE_HANDLE_FAILED, - "handle creation of %s failed", - uuid_utoa (ca_data->p_stat.ia_gfid)); - errno = ESTALE; - goto out; - } - - glfs_iatt_to_stat (fs, &ca_data->p_stat, &up_inode_arg->p_buf); - } - up_inode_arg->p_object = p_object; - - /* In case of RENAME, update old parent as well */ - if (ca_data->flags & GFAPI_UP_RENAME) { - oldp_object = glfs_h_find_handle (fs, - ca_data->oldp_stat.ia_gfid, - GFAPI_HANDLE_LENGTH); - if (!oldp_object) { - gf_msg (THIS->name, GF_LOG_DEBUG, errno, - API_MSG_CREATE_HANDLE_FAILED, - "handle creation of %s failed", - uuid_utoa (ca_data->oldp_stat.ia_gfid)); - errno = ESTALE; - /* By the time we receive upcall old parent_dir may - * have got removed. We still need to send upcall - * for the file/dir and current parent handles. */ - up_inode_arg->oldp_object = NULL; - ret = 0; - } - - glfs_iatt_to_stat (fs, &ca_data->oldp_stat, - &up_inode_arg->oldp_buf); - } - up_inode_arg->oldp_object = oldp_object; - - up_arg->reason = GLFS_UPCALL_INODE_INVALIDATE; - up_arg->event = up_inode_arg; - up_arg->free_event = glfs_free_upcall_inode; - - ret = 0; + int ret = -1; + struct glfs_object *p_object = NULL; + struct glfs_object *oldp_object = NULL; + struct glfs_object *object = NULL; + struct gf_upcall_cache_invalidation *ca_data = NULL; + struct glfs_upcall_inode *up_inode_arg = NULL; + + ca_data = upcall_data->data; + GF_VALIDATE_OR_GOTO("glfs_h_poll_cache_invalidation", ca_data, out); + + object = glfs_h_find_handle(fs, upcall_data->gfid, GFAPI_HANDLE_LENGTH); + if (!object) { + /* The reason handle creation will fail is because we + * couldn't find the inode in the gfapi inode table. + * + * But since application would have taken inode_ref, the + * only case when this can happen is when it has closed + * the handle and hence will no more be interested in + * the upcall for this particular gfid. + */ + gf_msg(THIS->name, GF_LOG_DEBUG, errno, API_MSG_CREATE_HANDLE_FAILED, + "handle creation of %s failed", uuid_utoa(upcall_data->gfid)); + errno = ESTALE; + goto out; + } + + up_inode_arg = GF_CALLOC(1, sizeof(struct glfs_upcall_inode), + glfs_mt_upcall_inode_t); + GF_VALIDATE_OR_GOTO("glfs_h_poll_cache_invalidation", up_inode_arg, out); + + up_inode_arg->object = object; + up_inode_arg->flags = ca_data->flags; + up_inode_arg->expire_time_attr = ca_data->expire_time_attr; + + /* XXX: Update stat as well in case of UP_*_TIMES. + * This will be addressed as part of INODE_UPDATE */ + if (ca_data->flags & GFAPI_INODE_UPDATE_FLAGS) { + glfs_iatt_to_stat(fs, &ca_data->stat, &up_inode_arg->buf); + } + + if (ca_data->flags & GFAPI_UP_PARENT_TIMES) { + p_object = glfs_h_find_handle(fs, ca_data->p_stat.ia_gfid, + GFAPI_HANDLE_LENGTH); + if (!p_object) { + gf_msg(THIS->name, GF_LOG_DEBUG, errno, + API_MSG_CREATE_HANDLE_FAILED, "handle creation of %s failed", + uuid_utoa(ca_data->p_stat.ia_gfid)); + errno = ESTALE; + goto out; + } + + glfs_iatt_to_stat(fs, &ca_data->p_stat, &up_inode_arg->p_buf); + } + up_inode_arg->p_object = p_object; + + /* In case of RENAME, update old parent as well */ + if (ca_data->flags & GFAPI_UP_RENAME) { + oldp_object = glfs_h_find_handle(fs, ca_data->oldp_stat.ia_gfid, + GFAPI_HANDLE_LENGTH); + if (!oldp_object) { + gf_msg(THIS->name, GF_LOG_DEBUG, errno, + API_MSG_CREATE_HANDLE_FAILED, "handle creation of %s failed", + uuid_utoa(ca_data->oldp_stat.ia_gfid)); + errno = ESTALE; + /* By the time we receive upcall old parent_dir may + * have got removed. We still need to send upcall + * for the file/dir and current parent handles. */ + up_inode_arg->oldp_object = NULL; + ret = 0; + } + + glfs_iatt_to_stat(fs, &ca_data->oldp_stat, &up_inode_arg->oldp_buf); + } + up_inode_arg->oldp_object = oldp_object; + + up_arg->reason = GLFS_UPCALL_INODE_INVALIDATE; + up_arg->event = up_inode_arg; + up_arg->free_event = glfs_free_upcall_inode; + + ret = 0; out: - if (ret) { - /* Close p_object and oldp_object as well if being referenced.*/ - if (object) - glfs_h_close (object); - - /* Set reason to prevent applications from using ->event */ - up_arg->reason = GLFS_UPCALL_EVENT_NULL; - GF_FREE (up_inode_arg); - } - return ret; + if (ret) { + /* Close p_object and oldp_object as well if being referenced.*/ + if (object) + glfs_h_close(object); + + /* Set reason to prevent applications from using ->event */ + up_arg->reason = GLFS_UPCALL_EVENT_NULL; + GF_FREE(up_inode_arg); + } + return ret; } -void glfs_release_upcall (void *ptr) +void +glfs_release_upcall(void *ptr) { - struct glfs_upcall *to_free = ptr; + struct glfs_upcall *to_free = ptr; - if (to_free->event) - to_free->free_event (to_free->event); + if (to_free->event) + to_free->free_event(to_free->event); } /* @@ -2045,123 +2066,120 @@ void glfs_release_upcall (void *ptr) * cannot be freed while in this routine. */ int -pub_glfs_h_poll_upcall (struct glfs *fs, struct glfs_upcall **up_arg) +pub_glfs_h_poll_upcall(struct glfs *fs, struct glfs_upcall **up_arg) { - upcall_entry *u_list = NULL; - upcall_entry *tmp = NULL; - xlator_t *subvol = NULL; - glusterfs_ctx_t *ctx = NULL; - int ret = -1; - struct gf_upcall *upcall_data = NULL; - - DECLARE_OLD_THIS; - - if (!up_arg) { - errno = EINVAL; - goto err; - } - - __GLFS_ENTRY_VALIDATE_FS (fs, err); - - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - errno = EIO; - goto restore; - } - - /* Ideally applications should stop polling before calling - * 'glfs_fini'. Yet cross check if cleanup has started. */ - pthread_mutex_lock (&fs->mutex); + upcall_entry *u_list = NULL; + upcall_entry *tmp = NULL; + xlator_t *subvol = NULL; + glusterfs_ctx_t *ctx = NULL; + int ret = -1; + struct gf_upcall *upcall_data = NULL; + + DECLARE_OLD_THIS; + + if (!up_arg) { + errno = EINVAL; + goto err; + } + + __GLFS_ENTRY_VALIDATE_FS(fs, err); + + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + errno = EIO; + goto restore; + } + + /* Ideally applications should stop polling before calling + * 'glfs_fini'. Yet cross check if cleanup has started. */ + pthread_mutex_lock(&fs->mutex); + { + ctx = fs->ctx; + + if (ctx->cleanup_started) { + pthread_mutex_unlock(&fs->mutex); + goto out; + } + + fs->pin_refcnt++; + + /* once we call this function, the applications seems to be + * interested in events, enable caching them */ + fs->cache_upcalls = _gf_true; + } + pthread_mutex_unlock(&fs->mutex); + + pthread_mutex_lock(&fs->upcall_list_mutex); + { + list_for_each_entry_safe(u_list, tmp, &fs->upcall_list, upcall_list) { - ctx = fs->ctx; - - if (ctx->cleanup_started) { - pthread_mutex_unlock (&fs->mutex); - goto out; + list_del_init(&u_list->upcall_list); + upcall_data = &u_list->upcall_data; + break; + } + } + /* No other thread can delete this entry. So unlock it */ + pthread_mutex_unlock(&fs->upcall_list_mutex); + + if (upcall_data) { + switch (upcall_data->event_type) { + case GF_UPCALL_CACHE_INVALIDATION: + *up_arg = GLFS_CALLOC(1, sizeof(struct gf_upcall), + glfs_release_upcall, + glfs_mt_upcall_entry_t); + if (!*up_arg) { + errno = ENOMEM; + break; /* goto free u_list */ } - fs->pin_refcnt++; - - /* once we call this function, the applications seems to be - * interested in events, enable caching them */ - fs->cache_upcalls = _gf_true; - } - pthread_mutex_unlock (&fs->mutex); + /* XXX: Need to revisit this to support + * GLFS_UPCALL_INODE_UPDATE if required. */ + ret = glfs_h_poll_cache_invalidation(fs, *up_arg, upcall_data); + if (ret || (*up_arg)->reason == GLFS_UPCALL_EVENT_NULL) { + /* It could so happen that the file which got + * upcall notification may have got deleted by + * the same client. Irrespective of the error, + * return with an error or success+ENOENT. */ + if ((*up_arg)->reason == GLFS_UPCALL_EVENT_NULL) + errno = ENOENT; - pthread_mutex_lock (&fs->upcall_list_mutex); - { - list_for_each_entry_safe (u_list, tmp, - &fs->upcall_list, - upcall_list) { - list_del_init (&u_list->upcall_list); - upcall_data = &u_list->upcall_data; - break; + GLFS_FREE(*up_arg); + *up_arg = NULL; } - } - /* No other thread can delete this entry. So unlock it */ - pthread_mutex_unlock (&fs->upcall_list_mutex); - - if (upcall_data) { - switch (upcall_data->event_type) { - case GF_UPCALL_CACHE_INVALIDATION: - *up_arg = GLFS_CALLOC (1, sizeof (struct gf_upcall), - glfs_release_upcall, - glfs_mt_upcall_entry_t); - if (!*up_arg) { - errno = ENOMEM; - break; /* goto free u_list */ - } - - /* XXX: Need to revisit this to support - * GLFS_UPCALL_INODE_UPDATE if required. */ - ret = glfs_h_poll_cache_invalidation (fs, *up_arg, - upcall_data); - if (ret - || (*up_arg)->reason == GLFS_UPCALL_EVENT_NULL) { - /* It could so happen that the file which got - * upcall notification may have got deleted by - * the same client. Irrespective of the error, - * return with an error or success+ENOENT. */ - if ((*up_arg)->reason == GLFS_UPCALL_EVENT_NULL) - errno = ENOENT; - - GLFS_FREE (*up_arg); - *up_arg = NULL; - } - break; - case GF_UPCALL_RECALL_LEASE: - gf_log ("glfs_h_poll_upcall", GF_LOG_DEBUG, - "UPCALL_RECALL_LEASE is not implemented yet"); - /* fallthrough till we support leases */ - case GF_UPCALL_EVENT_NULL: + break; + case GF_UPCALL_RECALL_LEASE: + gf_log("glfs_h_poll_upcall", GF_LOG_DEBUG, + "UPCALL_RECALL_LEASE is not implemented yet"); + /* fallthrough till we support leases */ + case GF_UPCALL_EVENT_NULL: /* no 'default:' label, to force handling all upcall events */ - errno = ENOENT; - break; - } - - GF_FREE (u_list->upcall_data.data); - GF_FREE (u_list); - } else { - /* fs->upcall_list was empty, no upcall events cached */ errno = ENOENT; + break; } - ret = 0; + GF_FREE(u_list->upcall_data.data); + GF_FREE(u_list); + } else { + /* fs->upcall_list was empty, no upcall events cached */ + errno = ENOENT; + } + + ret = 0; out: - pthread_mutex_lock (&fs->mutex); - { - fs->pin_refcnt--; - } - pthread_mutex_unlock (&fs->mutex); + pthread_mutex_lock(&fs->mutex); + { + fs->pin_refcnt--; + } + pthread_mutex_unlock(&fs->mutex); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); restore: - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; err: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_poll_upcall, 3.7.16); @@ -2180,72 +2198,70 @@ static gf_boolean_t log_upcall370 = _gf_true; /* log once */ * WARNING: this function will be removed in the future. */ int -pub_glfs_h_poll_upcall370 (struct glfs *fs, struct glfs_callback_arg *up_arg) +pub_glfs_h_poll_upcall370(struct glfs *fs, struct glfs_callback_arg *up_arg) { - struct glfs_upcall *upcall = NULL; - int ret = -1; - - if (log_upcall370) { - log_upcall370 = _gf_false; - gf_log (THIS->name, GF_LOG_WARNING, "this application is " - "compiled against an old version of libgfapi, it " - "should use glfs_free() to release the structure " - "returned by glfs_h_poll_upcall() - for more details, " - "see http://review.gluster.org/14701"); - } + struct glfs_upcall *upcall = NULL; + int ret = -1; + + if (log_upcall370) { + log_upcall370 = _gf_false; + gf_log(THIS->name, GF_LOG_WARNING, + "this application is " + "compiled against an old version of libgfapi, it " + "should use glfs_free() to release the structure " + "returned by glfs_h_poll_upcall() - for more details, " + "see http://review.gluster.org/14701"); + } + + ret = pub_glfs_h_poll_upcall(fs, &upcall); + if (ret == 0) { + up_arg->fs = fs; + if (errno == ENOENT || upcall->event == NULL) { + up_arg->reason = GLFS_UPCALL_EVENT_NULL; + goto out; + } + + up_arg->reason = upcall->reason; + + if (upcall->reason == GLFS_UPCALL_INODE_INVALIDATE) { + struct glfs_callback_inode_arg *cb_inode = NULL; + struct glfs_upcall_inode *up_inode = NULL; + + cb_inode = GF_CALLOC(1, sizeof(struct glfs_callback_inode_arg), + glfs_mt_upcall_inode_t); + if (!cb_inode) { + errno = ENOMEM; + ret = -1; + goto out; + } - ret = pub_glfs_h_poll_upcall (fs, &upcall); - if (ret == 0) { - up_arg->fs = fs; - if (errno == ENOENT || upcall->event == NULL) { - up_arg->reason = GLFS_UPCALL_EVENT_NULL; - goto out; - } + up_inode = upcall->event; - up_arg->reason = upcall->reason; - - if (upcall->reason == GLFS_UPCALL_INODE_INVALIDATE) { - struct glfs_callback_inode_arg *cb_inode = NULL; - struct glfs_upcall_inode *up_inode = NULL; - - cb_inode = GF_CALLOC (1, - sizeof (struct glfs_callback_inode_arg), - glfs_mt_upcall_inode_t); - if (!cb_inode) { - errno = ENOMEM; - ret = -1; - goto out; - } - - up_inode = upcall->event; - - /* copy attributes one by one, the memory layout might - * be different between the old glfs_callback_inode_arg - * and new glfs_upcall_inode */ - cb_inode->object = up_inode->object; - cb_inode->flags = up_inode->flags; - memcpy (&cb_inode->buf, &up_inode->buf, - sizeof (struct stat)); - cb_inode->expire_time_attr = up_inode->expire_time_attr; - cb_inode->p_object = up_inode->p_object; - memcpy (&cb_inode->p_buf, &up_inode->p_buf, - sizeof (struct stat)); - cb_inode->oldp_object = up_inode->oldp_object; - memcpy (&cb_inode->oldp_buf, &up_inode->oldp_buf, - sizeof (struct stat)); - - up_arg->event_arg = cb_inode; - } + /* copy attributes one by one, the memory layout might + * be different between the old glfs_callback_inode_arg + * and new glfs_upcall_inode */ + cb_inode->object = up_inode->object; + cb_inode->flags = up_inode->flags; + memcpy(&cb_inode->buf, &up_inode->buf, sizeof(struct stat)); + cb_inode->expire_time_attr = up_inode->expire_time_attr; + cb_inode->p_object = up_inode->p_object; + memcpy(&cb_inode->p_buf, &up_inode->p_buf, sizeof(struct stat)); + cb_inode->oldp_object = up_inode->oldp_object; + memcpy(&cb_inode->oldp_buf, &up_inode->oldp_buf, + sizeof(struct stat)); + + up_arg->event_arg = cb_inode; } + } out: - if (upcall) { - /* we can not use glfs_free() here, objects need to stay */ - GF_FREE (upcall->event); - GF_FREE (upcall); - } + if (upcall) { + /* we can not use glfs_free() here, objects need to stay */ + GF_FREE(upcall->event); + GF_FREE(upcall); + } - return ret; + return ret; } GFAPI_SYMVER_PUBLIC(glfs_h_poll_upcall370, glfs_h_poll_upcall, 3.7.0); @@ -2255,123 +2271,121 @@ GFAPI_SYMVER_PUBLIC(glfs_h_poll_upcall370, glfs_h_poll_upcall, 3.7.0); #include int -pub_glfs_h_acl_set (struct glfs *fs, struct glfs_object *object, - const acl_type_t type, const acl_t acl) +pub_glfs_h_acl_set(struct glfs *fs, struct glfs_object *object, + const acl_type_t type, const acl_t acl) { - int ret = -1; - char *acl_s = NULL; - const char *acl_key = NULL; - struct glfs_object *new_object = NULL; + int ret = -1; + char *acl_s = NULL; + const char *acl_key = NULL; + struct glfs_object *new_object = NULL; - DECLARE_OLD_THIS; + DECLARE_OLD_THIS; - if (!object || !acl) { - errno = EINVAL; - return ret; - } + if (!object || !acl) { + errno = EINVAL; + return ret; + } - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - acl_key = gf_posix_acl_get_key (type); - if (!acl_key) - goto out; + acl_key = gf_posix_acl_get_key(type); + if (!acl_key) + goto out; - acl_s = acl_to_any_text (acl, NULL, ',', - TEXT_ABBREVIATE | TEXT_NUMERIC_IDS); - if (!acl_s) - goto out; + acl_s = acl_to_any_text(acl, NULL, ',', TEXT_ABBREVIATE | TEXT_NUMERIC_IDS); + if (!acl_s) + goto out; - if (IA_ISLNK (object->inode->ia_type)) { - new_object = glfs_h_resolve_symlink (fs, object); - if (new_object == NULL) - goto out; - } else - new_object = object; + if (IA_ISLNK(object->inode->ia_type)) { + new_object = glfs_h_resolve_symlink(fs, object); + if (new_object == NULL) + goto out; + } else + new_object = object; - ret = pub_glfs_h_setxattrs (fs, new_object, acl_key, acl_s, - strlen (acl_s) + 1, 0); + ret = pub_glfs_h_setxattrs(fs, new_object, acl_key, acl_s, + strlen(acl_s) + 1, 0); - acl_free (acl_s); + acl_free(acl_s); out: - if (IA_ISLNK (object->inode->ia_type) && new_object) - glfs_h_close (new_object); + if (IA_ISLNK(object->inode->ia_type) && new_object) + glfs_h_close(new_object); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } acl_t -pub_glfs_h_acl_get (struct glfs *fs, struct glfs_object *object, - const acl_type_t type) +pub_glfs_h_acl_get(struct glfs *fs, struct glfs_object *object, + const acl_type_t type) { - int ret = 0; - acl_t acl = NULL; - char *acl_s = NULL; - dict_t *xattr = NULL; - const char *acl_key = NULL; - struct glfs_object *new_object = NULL; - - DECLARE_OLD_THIS; - - if (!object) { - errno = EINVAL; - return NULL; - } + int ret = 0; + acl_t acl = NULL; + char *acl_s = NULL; + dict_t *xattr = NULL; + const char *acl_key = NULL; + struct glfs_object *new_object = NULL; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + DECLARE_OLD_THIS; - acl_key = gf_posix_acl_get_key (type); - if (!acl_key) - goto out; + if (!object) { + errno = EINVAL; + return NULL; + } - if (IA_ISLNK (object->inode->ia_type)) { - new_object = glfs_h_resolve_symlink (fs, object); - if (new_object == NULL) - goto out; - } else - new_object = object; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - ret = glfs_h_getxattrs_common (fs, new_object, &xattr, acl_key, - _gf_false); - if (ret) - goto out; + acl_key = gf_posix_acl_get_key(type); + if (!acl_key) + goto out; - ret = dict_get_str (xattr, (char *)acl_key, &acl_s); - if (ret) - goto out; + if (IA_ISLNK(object->inode->ia_type)) { + new_object = glfs_h_resolve_symlink(fs, object); + if (new_object == NULL) + goto out; + } else + new_object = object; + + ret = glfs_h_getxattrs_common(fs, new_object, &xattr, acl_key, _gf_false); + if (ret) + goto out; - acl = acl_from_text (acl_s); + ret = dict_get_str(xattr, (char *)acl_key, &acl_s); + if (ret) + goto out; + + acl = acl_from_text(acl_s); out: - if (xattr) - dict_unref(xattr); + if (xattr) + dict_unref(xattr); - if (IA_ISLNK (object->inode->ia_type) && new_object) - glfs_h_close (new_object); + if (IA_ISLNK(object->inode->ia_type) && new_object) + glfs_h_close(new_object); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return acl; + return acl; } #else /* !HAVE_ACL_LIBACL_H */ acl_t -pub_glfs_h_acl_get (struct glfs *fs, struct glfs_object *object, - const acl_type_t type) +pub_glfs_h_acl_get(struct glfs *fs, struct glfs_object *object, + const acl_type_t type) { - errno = ENOTSUP; - return NULL; + errno = ENOTSUP; + return NULL; } int -pub_glfs_h_acl_set (struct glfs *fs, struct glfs_object *object, - const acl_type_t type, const acl_t acl) +pub_glfs_h_acl_set(struct glfs *fs, struct glfs_object *object, + const acl_type_t type, const acl_t acl) { - errno = ENOTSUP; - return -1; + errno = ENOTSUP; + return -1; } #endif GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_acl_set, 3.7.0); @@ -2379,153 +2393,158 @@ GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_acl_get, 3.7.0); /* The API to perform read using anonymous fd */ ssize_t -pub_glfs_h_anonymous_read (struct glfs *fs, struct glfs_object *object, - const void *buf, size_t count, off_t offset) +pub_glfs_h_anonymous_read(struct glfs *fs, struct glfs_object *object, + const void *buf, size_t count, off_t offset) { - struct iovec iov = {0, }; - ssize_t ret = 0; - - /* validate in args */ - if ((fs == NULL) || (object == NULL)) { - errno = EINVAL; - return -1; - } + struct iovec iov = { + 0, + }; + ssize_t ret = 0; + + /* validate in args */ + if ((fs == NULL) || (object == NULL)) { + errno = EINVAL; + return -1; + } - iov.iov_base = (void *) buf; - iov.iov_len = count; + iov.iov_base = (void *)buf; + iov.iov_len = count; - ret = glfs_anonymous_preadv (fs, object, &iov, 1, offset, 0); + ret = glfs_anonymous_preadv(fs, object, &iov, 1, offset, 0); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_anonymous_read, 3.7.0); /* The API to perform write using anonymous fd */ ssize_t -pub_glfs_h_anonymous_write (struct glfs *fs, struct glfs_object *object, - const void *buf, size_t count, off_t offset) +pub_glfs_h_anonymous_write(struct glfs *fs, struct glfs_object *object, + const void *buf, size_t count, off_t offset) { - struct iovec iov = {0, }; - ssize_t ret = 0; - - /* validate in args */ - if ((fs == NULL) || (object == NULL)) { - errno = EINVAL; - return -1; - } + struct iovec iov = { + 0, + }; + ssize_t ret = 0; + + /* validate in args */ + if ((fs == NULL) || (object == NULL)) { + errno = EINVAL; + return -1; + } - iov.iov_base = (void *) buf; - iov.iov_len = count; + iov.iov_base = (void *)buf; + iov.iov_len = count; - ret = glfs_anonymous_pwritev (fs, object, &iov, 1, offset, 0); + ret = glfs_anonymous_pwritev(fs, object, &iov, 1, offset, 0); - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_anonymous_write, 3.7.0); -struct glfs_object* -pub_glfs_object_copy (struct glfs_object *src) +struct glfs_object * +pub_glfs_object_copy(struct glfs_object *src) { - struct glfs_object *object = NULL; + struct glfs_object *object = NULL; - GF_VALIDATE_OR_GOTO ("glfs_dup_object", src, out); + GF_VALIDATE_OR_GOTO("glfs_dup_object", src, out); - object = GF_CALLOC (1, sizeof(struct glfs_object), - glfs_mt_glfs_object_t); - if (object == NULL) { - errno = ENOMEM; - gf_msg (THIS->name, GF_LOG_WARNING, errno, - API_MSG_CREATE_HANDLE_FAILED, - "glfs_dup_object for gfid-%s failed", - uuid_utoa (src->inode->gfid)); - return NULL; - } + object = GF_CALLOC(1, sizeof(struct glfs_object), glfs_mt_glfs_object_t); + if (object == NULL) { + errno = ENOMEM; + gf_msg(THIS->name, GF_LOG_WARNING, errno, API_MSG_CREATE_HANDLE_FAILED, + "glfs_dup_object for gfid-%s failed", + uuid_utoa(src->inode->gfid)); + return NULL; + } - object->inode = inode_ref (src->inode); - gf_uuid_copy (object->gfid, src->inode->gfid); + object->inode = inode_ref(src->inode); + gf_uuid_copy(object->gfid, src->inode->gfid); out: - return object; + return object; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_object_copy, 3.11.0); -struct glfs_object* -pub_glfs_xreaddirplus_get_object (struct glfs_xreaddirp_stat *xstat) +struct glfs_object * +pub_glfs_xreaddirplus_get_object(struct glfs_xreaddirp_stat *xstat) { - GF_VALIDATE_OR_GOTO ("glfs_xreaddirplus_get_object", xstat, out); + GF_VALIDATE_OR_GOTO("glfs_xreaddirplus_get_object", xstat, out); - if (!(xstat->flags_handled & GFAPI_XREADDIRP_HANDLE)) - gf_msg (THIS->name, GF_LOG_ERROR, errno, - LG_MSG_INVALID_ARG, - "GFAPI_XREADDIRP_HANDLE is not set. Flags" - "handled for xstat(%p) are (%x)", - xstat, xstat->flags_handled); + if (!(xstat->flags_handled & GFAPI_XREADDIRP_HANDLE)) + gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG, + "GFAPI_XREADDIRP_HANDLE is not set. Flags" + "handled for xstat(%p) are (%x)", + xstat, xstat->flags_handled); - return xstat->object; + return xstat->object; out: - return NULL; + return NULL; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_xreaddirplus_get_object, 3.11.0); int -pub_glfs_h_lease (struct glfs *fs, struct glfs_object *object, - struct glfs_lease *lease) +pub_glfs_h_lease(struct glfs *fs, struct glfs_object *object, + struct glfs_lease *lease) { - int ret = -1; - xlator_t *subvol = NULL; - inode_t *inode = NULL; - loc_t loc = {0, }; - struct gf_lease gf_lease = {0, }; - - /* validate in args */ - if ((fs == NULL) || (object == NULL)) { - errno = EINVAL; - return -1; - } + int ret = -1; + xlator_t *subvol = NULL; + inode_t *inode = NULL; + loc_t loc = { + 0, + }; + struct gf_lease gf_lease = { + 0, + }; + + /* validate in args */ + if ((fs == NULL) || (object == NULL)) { + errno = EINVAL; + return -1; + } - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - /* get the active volume */ - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } + /* get the active volume */ + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } - /* get/refresh the in arg objects inode in correlation to the xlator */ - inode = glfs_resolve_inode (fs, subvol, object); - if (!inode) { - errno = ESTALE; - goto out; - } + /* get/refresh the in arg objects inode in correlation to the xlator */ + inode = glfs_resolve_inode(fs, subvol, object); + if (!inode) { + errno = ESTALE; + goto out; + } - /* populate loc */ - GLFS_LOC_FILL_INODE (inode, loc, out); + /* populate loc */ + GLFS_LOC_FILL_INODE(inode, loc, out); - glfs_lease_to_gf_lease (lease, &gf_lease); + glfs_lease_to_gf_lease(lease, &gf_lease); - ret = syncop_lease (subvol, &loc, &gf_lease, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + ret = syncop_lease(subvol, &loc, &gf_lease, NULL, NULL); + DECODE_SYNCOP_ERR(ret); - gf_lease_to_glfs_lease (&gf_lease, lease); + gf_lease_to_glfs_lease(&gf_lease, lease); out: - loc_wipe (&loc); + loc_wipe(&loc); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - glfs_subvol_done (fs, subvol); + glfs_subvol_done(fs, subvol); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_lease, 4.0.0); diff --git a/api/src/glfs-master.c b/api/src/glfs-master.c index 9648bbbc03a..969095a8224 100644 --- a/api/src/glfs-master.c +++ b/api/src/glfs-master.c @@ -22,166 +22,153 @@ #include "glfs-mem-types.h" #include "gfapi-messages.h" - int -graph_setup (struct glfs *fs, glusterfs_graph_t *graph) +graph_setup(struct glfs *fs, glusterfs_graph_t *graph) { - xlator_t *new_subvol = NULL; - xlator_t *old_subvol = NULL; - inode_table_t *itable = NULL; - int ret = -1; - - new_subvol = graph->top; - - /* This is called in a bottom-up context, it should specifically - NOT be glfs_lock() - */ - pthread_mutex_lock (&fs->mutex); - { - if (new_subvol->switched || - new_subvol == fs->active_subvol || - new_subvol == fs->next_subvol || - new_subvol == fs->mip_subvol) { - /* Spurious CHILD_UP event on old graph */ - ret = 0; - goto unlock; - } - - if (!new_subvol->itable) { - itable = inode_table_new (131072, new_subvol); - if (!itable) { - errno = ENOMEM; - ret = -1; - goto unlock; - } - - new_subvol->itable = itable; - } - - old_subvol = fs->next_subvol; - fs->next_subvol = new_subvol; - fs->next_subvol->winds++; /* first ref */ - ret = 0; - } + xlator_t *new_subvol = NULL; + xlator_t *old_subvol = NULL; + inode_table_t *itable = NULL; + int ret = -1; + + new_subvol = graph->top; + + /* This is called in a bottom-up context, it should specifically + NOT be glfs_lock() + */ + pthread_mutex_lock(&fs->mutex); + { + if (new_subvol->switched || new_subvol == fs->active_subvol || + new_subvol == fs->next_subvol || new_subvol == fs->mip_subvol) { + /* Spurious CHILD_UP event on old graph */ + ret = 0; + goto unlock; + } + + if (!new_subvol->itable) { + itable = inode_table_new(131072, new_subvol); + if (!itable) { + errno = ENOMEM; + ret = -1; + goto unlock; + } + + new_subvol->itable = itable; + } + + old_subvol = fs->next_subvol; + fs->next_subvol = new_subvol; + fs->next_subvol->winds++; /* first ref */ + ret = 0; + } unlock: - pthread_mutex_unlock (&fs->mutex); + pthread_mutex_unlock(&fs->mutex); - if (old_subvol) - /* wasn't picked up so far, skip */ - glfs_subvol_done (fs, old_subvol); + if (old_subvol) + /* wasn't picked up so far, skip */ + glfs_subvol_done(fs, old_subvol); - return ret; + return ret; } - int -notify (xlator_t *this, int event, void *data, ...) +notify(xlator_t *this, int event, void *data, ...) { - glusterfs_graph_t *graph = NULL; - struct glfs *fs = NULL; - - graph = data; - fs = this->private; - - switch (event) { - case GF_EVENT_GRAPH_NEW: - gf_msg (this->name, GF_LOG_INFO, 0, API_MSG_NEW_GRAPH, - "New graph %s (%d) coming up", - uuid_utoa ((unsigned char *)graph->graph_uuid), - graph->id); - break; - case GF_EVENT_CHILD_UP: - pthread_mutex_lock (&fs->mutex); - { - graph->used = 1; - } - pthread_mutex_unlock (&fs->mutex); - graph_setup (fs, graph); - glfs_init_done (fs, 0); - break; - case GF_EVENT_CHILD_DOWN: - pthread_mutex_lock (&fs->mutex); - { - graph->used = 0; - pthread_cond_broadcast (&fs->child_down_cond); - } - pthread_mutex_unlock (&fs->mutex); - glfs_init_done (fs, 1); - break; - case GF_EVENT_CHILD_CONNECTING: - break; + glusterfs_graph_t *graph = NULL; + struct glfs *fs = NULL; + + graph = data; + fs = this->private; + + switch (event) { + case GF_EVENT_GRAPH_NEW: + gf_msg(this->name, GF_LOG_INFO, 0, API_MSG_NEW_GRAPH, + "New graph %s (%d) coming up", + uuid_utoa((unsigned char *)graph->graph_uuid), graph->id); + break; + case GF_EVENT_CHILD_UP: + pthread_mutex_lock(&fs->mutex); + { + graph->used = 1; + } + pthread_mutex_unlock(&fs->mutex); + graph_setup(fs, graph); + glfs_init_done(fs, 0); + break; + case GF_EVENT_CHILD_DOWN: + pthread_mutex_lock(&fs->mutex); + { + graph->used = 0; + pthread_cond_broadcast(&fs->child_down_cond); + } + pthread_mutex_unlock(&fs->mutex); + glfs_init_done(fs, 1); + break; + case GF_EVENT_CHILD_CONNECTING: + break; case GF_EVENT_UPCALL: - glfs_process_upcall_event (fs, data); - break; - default: - gf_msg_debug (this->name, 0, "got notify event %d", event); - break; - } - - return 0; + glfs_process_upcall_event(fs, data); + break; + default: + gf_msg_debug(this->name, 0, "got notify event %d", event); + break; + } + + return 0; } - int -mem_acct_init (xlator_t *this) +mem_acct_init(xlator_t *this) { - int ret = -1; + int ret = -1; - if (!this) - return ret; + if (!this) + return ret; - ret = xlator_mem_acct_init (this, glfs_mt_end + 1); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, - API_MSG_MEM_ACCT_INIT_FAILED, "Failed to initialise " - "memory accounting"); - return ret; - } + ret = xlator_mem_acct_init(this, glfs_mt_end + 1); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, API_MSG_MEM_ACCT_INIT_FAILED, + "Failed to initialise " + "memory accounting"); + return ret; + } - return 0; + return 0; } - int -init (xlator_t *this) +init(xlator_t *this) { - return 0; + return 0; } - void -fini (xlator_t *this) +fini(xlator_t *this) { - } /* place-holder fops */ int -glfs_forget (xlator_t *this, inode_t *inode) +glfs_forget(xlator_t *this, inode_t *inode) { - return 0; + return 0; } int -glfs_release (xlator_t *this, fd_t *fd) +glfs_release(xlator_t *this, fd_t *fd) { - return 0; + return 0; } int -glfs_releasedir (xlator_t *this, fd_t *fd) +glfs_releasedir(xlator_t *this, fd_t *fd) { - return 0; + return 0; } struct xlator_dumpops dumpops; - struct xlator_fops fops; - -struct xlator_cbks cbks = { - .forget = glfs_forget, - .release = glfs_release, - .releasedir = glfs_releasedir -}; +struct xlator_cbks cbks = {.forget = glfs_forget, + .release = glfs_release, + .releasedir = glfs_releasedir}; diff --git a/api/src/glfs-mgmt.c b/api/src/glfs-mgmt.c index fac903b805a..87b62173689 100644 --- a/api/src/glfs-mgmt.c +++ b/api/src/glfs-mgmt.c @@ -8,7 +8,6 @@ cases as published by the Free Software Foundation. */ - #include #include #include @@ -38,1063 +37,1034 @@ #include "gfapi-messages.h" #include "syscall.h" -int glfs_volfile_fetch (struct glfs *fs); -int32_t glfs_get_volume_info_rpc (call_frame_t *frame, xlator_t *this, - struct glfs *fs); +int +glfs_volfile_fetch(struct glfs *fs); +int32_t +glfs_get_volume_info_rpc(call_frame_t *frame, xlator_t *this, struct glfs *fs); int -glfs_process_volfp (struct glfs *fs, FILE *fp) +glfs_process_volfp(struct glfs *fs, FILE *fp) { - glusterfs_graph_t *graph = NULL; - int ret = -1; - xlator_t *trav = NULL; - glusterfs_ctx_t *ctx = NULL; - - ctx = fs->ctx; - graph = glusterfs_graph_construct (fp); - if (!graph) { - gf_msg ("glfs", GF_LOG_ERROR, errno, - API_MSG_GRAPH_CONSTRUCT_FAILED, - "failed to construct the graph"); - goto out; - } - - for (trav = graph->first; trav; trav = trav->next) { - if (strcmp (trav->type, "mount/api") == 0) { - gf_msg ("glfs", GF_LOG_ERROR, EINVAL, - API_MSG_API_XLATOR_ERROR, - "api master xlator cannot be specified " - "in volume file"); - goto out; - } - } - - ret = glusterfs_graph_prepare (graph, ctx, fs->volname); - if (ret) { - glusterfs_graph_destroy (graph); - goto out; - } - - ret = glusterfs_graph_activate (graph, ctx); - - if (ret) { - glusterfs_graph_destroy (graph); - goto out; - } - - gf_log_dump_graph (fp, graph); - - ret = 0; + glusterfs_graph_t *graph = NULL; + int ret = -1; + xlator_t *trav = NULL; + glusterfs_ctx_t *ctx = NULL; + + ctx = fs->ctx; + graph = glusterfs_graph_construct(fp); + if (!graph) { + gf_msg("glfs", GF_LOG_ERROR, errno, API_MSG_GRAPH_CONSTRUCT_FAILED, + "failed to construct the graph"); + goto out; + } + + for (trav = graph->first; trav; trav = trav->next) { + if (strcmp(trav->type, "mount/api") == 0) { + gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_API_XLATOR_ERROR, + "api master xlator cannot be specified " + "in volume file"); + goto out; + } + } + + ret = glusterfs_graph_prepare(graph, ctx, fs->volname); + if (ret) { + glusterfs_graph_destroy(graph); + goto out; + } + + ret = glusterfs_graph_activate(graph, ctx); + + if (ret) { + glusterfs_graph_destroy(graph); + goto out; + } + + gf_log_dump_graph(fp, graph); + + ret = 0; out: - if (fp) - fclose (fp); + if (fp) + fclose(fp); - if (!ctx->active) { - ret = -1; - } + if (!ctx->active) { + ret = -1; + } - return ret; + return ret; } - int -mgmt_cbk_spec (struct rpc_clnt *rpc, void *mydata, void *data) +mgmt_cbk_spec(struct rpc_clnt *rpc, void *mydata, void *data) { - struct glfs *fs = NULL; - xlator_t *this = NULL; + struct glfs *fs = NULL; + xlator_t *this = NULL; - this = mydata; - fs = this->private; + this = mydata; + fs = this->private; - glfs_volfile_fetch (fs); + glfs_volfile_fetch(fs); - return 0; + return 0; } - int -mgmt_cbk_event (struct rpc_clnt *rpc, void *mydata, void *data) +mgmt_cbk_event(struct rpc_clnt *rpc, void *mydata, void *data) { - return 0; + return 0; } static int -mgmt_cbk_statedump (struct rpc_clnt *rpc, void *mydata, void *data) +mgmt_cbk_statedump(struct rpc_clnt *rpc, void *mydata, void *data) { - struct glfs *fs = NULL; - xlator_t *this = NULL; - gf_statedump target_pid = {0, }; - struct iovec *iov = NULL; - int ret = -1; - - this = mydata; - if (!this) { - gf_msg ("glfs", GF_LOG_ERROR, EINVAL, - API_MSG_STATEDUMP_FAILED, "NULL mydata"); - errno = EINVAL; - goto out; - } - - fs = this->private; - if (!fs) { - gf_msg ("glfs", GF_LOG_ERROR, EINVAL, - API_MSG_STATEDUMP_FAILED, "NULL glfs"); - errno = EINVAL; - goto out; - } - - iov = (struct iovec *)data; - if (!iov) { - gf_msg ("glfs", GF_LOG_ERROR, EINVAL, - API_MSG_STATEDUMP_FAILED, "NULL iovec data"); - errno = EINVAL; - goto out; - } - - ret = xdr_to_generic (*iov, &target_pid, - (xdrproc_t)xdr_gf_statedump); + struct glfs *fs = NULL; + xlator_t *this = NULL; + gf_statedump target_pid = { + 0, + }; + struct iovec *iov = NULL; + int ret = -1; + + this = mydata; + if (!this) { + gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_STATEDUMP_FAILED, + "NULL mydata"); + errno = EINVAL; + goto out; + } + + fs = this->private; + if (!fs) { + gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_STATEDUMP_FAILED, + "NULL glfs"); + errno = EINVAL; + goto out; + } + + iov = (struct iovec *)data; + if (!iov) { + gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_STATEDUMP_FAILED, + "NULL iovec data"); + errno = EINVAL; + goto out; + } + + ret = xdr_to_generic(*iov, &target_pid, (xdrproc_t)xdr_gf_statedump); + if (ret < 0) { + gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_STATEDUMP_FAILED, + "Failed to decode xdr response for GF_CBK_STATEDUMP"); + goto out; + } + + gf_msg_trace("glfs", 0, "statedump requested for pid: %d", target_pid.pid); + + if ((uint64_t)getpid() == target_pid.pid) { + gf_msg_debug("glfs", 0, "Taking statedump for pid: %d", target_pid.pid); + + ret = glfs_sysrq(fs, GLFS_SYSRQ_STATEDUMP); if (ret < 0) { - gf_msg ("glfs", GF_LOG_ERROR, EINVAL, - API_MSG_STATEDUMP_FAILED, - "Failed to decode xdr response for GF_CBK_STATEDUMP"); - goto out; - } - - gf_msg_trace ("glfs", 0, "statedump requested for pid: %d", - target_pid.pid); - - if ((uint64_t)getpid() == target_pid.pid) { - gf_msg_debug ("glfs", 0, "Taking statedump for pid: %d", - target_pid.pid); - - ret = glfs_sysrq (fs, GLFS_SYSRQ_STATEDUMP); - if (ret < 0) { - gf_msg ("glfs", GF_LOG_INFO, 0, - API_MSG_STATEDUMP_FAILED, - "statedump failed"); - } + gf_msg("glfs", GF_LOG_INFO, 0, API_MSG_STATEDUMP_FAILED, + "statedump failed"); } + } out: - return ret; + return ret; } rpcclnt_cb_actor_t mgmt_cbk_actors[GF_CBK_MAXVALUE] = { - [GF_CBK_FETCHSPEC] = {"FETCHSPEC", GF_CBK_FETCHSPEC, mgmt_cbk_spec }, - [GF_CBK_EVENT_NOTIFY] = {"EVENTNOTIFY", GF_CBK_EVENT_NOTIFY, - mgmt_cbk_event}, - [GF_CBK_STATEDUMP] = {"STATEDUMP", GF_CBK_STATEDUMP, mgmt_cbk_statedump}, + [GF_CBK_FETCHSPEC] = {"FETCHSPEC", GF_CBK_FETCHSPEC, mgmt_cbk_spec}, + [GF_CBK_EVENT_NOTIFY] = {"EVENTNOTIFY", GF_CBK_EVENT_NOTIFY, + mgmt_cbk_event}, + [GF_CBK_STATEDUMP] = {"STATEDUMP", GF_CBK_STATEDUMP, mgmt_cbk_statedump}, }; - struct rpcclnt_cb_program mgmt_cbk_prog = { - .progname = "GlusterFS Callback", - .prognum = GLUSTER_CBK_PROGRAM, - .progver = GLUSTER_CBK_VERSION, - .actors = mgmt_cbk_actors, - .numactors = GF_CBK_MAXVALUE, + .progname = "GlusterFS Callback", + .prognum = GLUSTER_CBK_PROGRAM, + .progver = GLUSTER_CBK_VERSION, + .actors = mgmt_cbk_actors, + .numactors = GF_CBK_MAXVALUE, }; char *clnt_handshake_procs[GF_HNDSK_MAXVALUE] = { - [GF_HNDSK_NULL] = "NULL", - [GF_HNDSK_SETVOLUME] = "SETVOLUME", - [GF_HNDSK_GETSPEC] = "GETSPEC", - [GF_HNDSK_PING] = "PING", - [GF_HNDSK_EVENT_NOTIFY] = "EVENTNOTIFY", - [GF_HNDSK_GET_VOLUME_INFO] = "GETVOLUMEINFO", + [GF_HNDSK_NULL] = "NULL", + [GF_HNDSK_SETVOLUME] = "SETVOLUME", + [GF_HNDSK_GETSPEC] = "GETSPEC", + [GF_HNDSK_PING] = "PING", + [GF_HNDSK_EVENT_NOTIFY] = "EVENTNOTIFY", + [GF_HNDSK_GET_VOLUME_INFO] = "GETVOLUMEINFO", }; rpc_clnt_prog_t clnt_handshake_prog = { - .progname = "GlusterFS Handshake", - .prognum = GLUSTER_HNDSK_PROGRAM, - .progver = GLUSTER_HNDSK_VERSION, - .procnames = clnt_handshake_procs, + .progname = "GlusterFS Handshake", + .prognum = GLUSTER_HNDSK_PROGRAM, + .progver = GLUSTER_HNDSK_VERSION, + .procnames = clnt_handshake_procs, }; - int -mgmt_submit_request (void *req, call_frame_t *frame, - glusterfs_ctx_t *ctx, - rpc_clnt_prog_t *prog, int procnum, - fop_cbk_fn_t cbkfn, xdrproc_t xdrproc) +mgmt_submit_request(void *req, call_frame_t *frame, glusterfs_ctx_t *ctx, + rpc_clnt_prog_t *prog, int procnum, fop_cbk_fn_t cbkfn, + xdrproc_t xdrproc) { - int ret = -1; - int count = 0; - struct iovec iov = {0, }; - struct iobuf *iobuf = NULL; - struct iobref *iobref = NULL; - ssize_t xdr_size = 0; - - iobref = iobref_new (); - if (!iobref) { - goto out; - } - - if (req) { - xdr_size = xdr_sizeof (xdrproc, req); - - iobuf = iobuf_get2 (ctx->iobuf_pool, xdr_size); - if (!iobuf) { - goto out; - }; - - iobref_add (iobref, iobuf); - - iov.iov_base = iobuf->ptr; - iov.iov_len = iobuf_pagesize (iobuf); - - /* Create the xdr payload */ - ret = xdr_serialize_generic (iov, req, xdrproc); - if (ret == -1) { - gf_msg (THIS->name, GF_LOG_WARNING, 0, - API_MSG_XDR_PAYLOAD_FAILED, - "failed to create XDR payload"); - goto out; - } - iov.iov_len = ret; - count = 1; - } - - /* Send the msg */ - ret = rpc_clnt_submit (ctx->mgmt, prog, procnum, cbkfn, - &iov, count, - NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL); + int ret = -1; + int count = 0; + struct iovec iov = { + 0, + }; + struct iobuf *iobuf = NULL; + struct iobref *iobref = NULL; + ssize_t xdr_size = 0; + + iobref = iobref_new(); + if (!iobref) { + goto out; + } + + if (req) { + xdr_size = xdr_sizeof(xdrproc, req); + + iobuf = iobuf_get2(ctx->iobuf_pool, xdr_size); + if (!iobuf) { + goto out; + }; + + iobref_add(iobref, iobuf); + + iov.iov_base = iobuf->ptr; + iov.iov_len = iobuf_pagesize(iobuf); + + /* Create the xdr payload */ + ret = xdr_serialize_generic(iov, req, xdrproc); + if (ret == -1) { + gf_msg(THIS->name, GF_LOG_WARNING, 0, API_MSG_XDR_PAYLOAD_FAILED, + "failed to create XDR payload"); + goto out; + } + iov.iov_len = ret; + count = 1; + } + + /* Send the msg */ + ret = rpc_clnt_submit(ctx->mgmt, prog, procnum, cbkfn, &iov, count, NULL, 0, + iobref, frame, NULL, 0, NULL, 0, NULL); out: - if (iobref) - iobref_unref (iobref); + if (iobref) + iobref_unref(iobref); - if (iobuf) - iobuf_unref (iobuf); - return ret; + if (iobuf) + iobuf_unref(iobuf); + return ret; } /* * Callback routine for 'GF_HNDSK_GET_VOLUME_INFO' rpc request */ int -mgmt_get_volinfo_cbk (struct rpc_req *req, struct iovec *iov, - int count, void *myframe) +mgmt_get_volinfo_cbk(struct rpc_req *req, struct iovec *iov, int count, + void *myframe) { - int ret = 0; - char *volume_id_str = NULL; - dict_t *dict = NULL; - char key[1024] = {0}; - gf_get_volume_info_rsp rsp = {0,}; - call_frame_t *frame = NULL; - glusterfs_ctx_t *ctx = NULL; - struct glfs *fs = NULL; - struct syncargs *args; - - frame = myframe; - ctx = frame->this->ctx; - args = frame->local; - - if (!ctx) { - gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL, - API_MSG_INVALID_ENTRY, "NULL context"); - errno = EINVAL; - ret = -1; - goto out; - } - - fs = ((xlator_t *)ctx->master)->private; - - if (-1 == req->rpc_status) { - gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL, - API_MSG_INVALID_ENTRY, - "GET_VOLUME_INFO RPC call is not successful"); - errno = EINVAL; - ret = -1; - goto out; - } - - ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_get_volume_info_rsp); - - if (ret < 0) { - gf_msg (frame->this->name, GF_LOG_ERROR, 0, - API_MSG_XDR_RESPONSE_DECODE_FAILED, - "Failed to decode xdr response for GET_VOLUME_INFO"); - goto out; - } - - gf_msg_debug (frame->this->name, 0, "Received resp to GET_VOLUME_INFO " - "RPC: %d", rsp.op_ret); - - if (rsp.op_ret == -1) { - errno = rsp.op_errno; - ret = -1; - goto out; - } - - if (!rsp.dict.dict_len) { - gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL, - API_MSG_INVALID_ENTRY, "Response received for " - "GET_VOLUME_INFO RPC call is not valid"); - ret = -1; - errno = EINVAL; - goto out; - } - - dict = dict_new (); - - if (!dict) { - ret = -1; - errno = ENOMEM; - goto out; - } - - ret = dict_unserialize (rsp.dict.dict_val, - rsp.dict.dict_len, - &dict); - - if (ret) { - errno = ENOMEM; - goto out; - } - - snprintf (key, sizeof (key), "volume_id"); - ret = dict_get_str (dict, key, &volume_id_str); - if (ret) { - errno = EINVAL; - goto out; - } - - ret = 0; + int ret = 0; + char *volume_id_str = NULL; + dict_t *dict = NULL; + char key[1024] = {0}; + gf_get_volume_info_rsp rsp = { + 0, + }; + call_frame_t *frame = NULL; + glusterfs_ctx_t *ctx = NULL; + struct glfs *fs = NULL; + struct syncargs *args; + + frame = myframe; + ctx = frame->this->ctx; + args = frame->local; + + if (!ctx) { + gf_msg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY, + "NULL context"); + errno = EINVAL; + ret = -1; + goto out; + } + + fs = ((xlator_t *)ctx->master)->private; + + if (-1 == req->rpc_status) { + gf_msg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY, + "GET_VOLUME_INFO RPC call is not successful"); + errno = EINVAL; + ret = -1; + goto out; + } + + ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_get_volume_info_rsp); + + if (ret < 0) { + gf_msg(frame->this->name, GF_LOG_ERROR, 0, + API_MSG_XDR_RESPONSE_DECODE_FAILED, + "Failed to decode xdr response for GET_VOLUME_INFO"); + goto out; + } + + gf_msg_debug(frame->this->name, 0, + "Received resp to GET_VOLUME_INFO " + "RPC: %d", + rsp.op_ret); + + if (rsp.op_ret == -1) { + errno = rsp.op_errno; + ret = -1; + goto out; + } + + if (!rsp.dict.dict_len) { + gf_msg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY, + "Response received for " + "GET_VOLUME_INFO RPC call is not valid"); + ret = -1; + errno = EINVAL; + goto out; + } + + dict = dict_new(); + + if (!dict) { + ret = -1; + errno = ENOMEM; + goto out; + } + + ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict); + + if (ret) { + errno = ENOMEM; + goto out; + } + + snprintf(key, sizeof(key), "volume_id"); + ret = dict_get_str(dict, key, &volume_id_str); + if (ret) { + errno = EINVAL; + goto out; + } + + ret = 0; out: - if (volume_id_str) { - gf_msg_debug (frame->this->name, 0, - "Volume Id: %s", volume_id_str); - pthread_mutex_lock (&fs->mutex); - gf_uuid_parse (volume_id_str, fs->vol_uuid); - pthread_mutex_unlock (&fs->mutex); - } + if (volume_id_str) { + gf_msg_debug(frame->this->name, 0, "Volume Id: %s", volume_id_str); + pthread_mutex_lock(&fs->mutex); + gf_uuid_parse(volume_id_str, fs->vol_uuid); + pthread_mutex_unlock(&fs->mutex); + } - if (ret) { - gf_msg (frame->this->name, GF_LOG_ERROR, errno, - API_MSG_GET_VOLINFO_CBK_FAILED, "In GET_VOLUME_INFO " - "cbk, received error: %s", strerror(errno)); - } + if (ret) { + gf_msg(frame->this->name, GF_LOG_ERROR, errno, + API_MSG_GET_VOLINFO_CBK_FAILED, + "In GET_VOLUME_INFO " + "cbk, received error: %s", + strerror(errno)); + } - if (dict) - dict_unref (dict); + if (dict) + dict_unref(dict); - if (rsp.dict.dict_val) - free (rsp.dict.dict_val); + if (rsp.dict.dict_val) + free(rsp.dict.dict_val); - if (rsp.op_errstr) - free (rsp.op_errstr); + if (rsp.op_errstr) + free(rsp.op_errstr); - gf_msg_debug (frame->this->name, 0, "Returning: %d", ret); + gf_msg_debug(frame->this->name, 0, "Returning: %d", ret); - __wake (args); + __wake(args); - return ret; + return ret; } int -pub_glfs_get_volumeid (struct glfs *fs, char *volid, size_t size) +pub_glfs_get_volumeid(struct glfs *fs, char *volid, size_t size) { - /* TODO: Define a global macro to store UUID size */ - size_t uuid_size = 16; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - pthread_mutex_lock (&fs->mutex); - { - /* check if the volume uuid is initialized */ - if (!gf_uuid_is_null (fs->vol_uuid)) { - pthread_mutex_unlock (&fs->mutex); - goto done; - } + /* TODO: Define a global macro to store UUID size */ + size_t uuid_size = 16; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + pthread_mutex_lock(&fs->mutex); + { + /* check if the volume uuid is initialized */ + if (!gf_uuid_is_null(fs->vol_uuid)) { + pthread_mutex_unlock(&fs->mutex); + goto done; } - pthread_mutex_unlock (&fs->mutex); + } + pthread_mutex_unlock(&fs->mutex); - /* Need to fetch volume_uuid */ - glfs_get_volume_info (fs); + /* Need to fetch volume_uuid */ + glfs_get_volume_info(fs); - if (gf_uuid_is_null (fs->vol_uuid)) { - gf_msg (THIS->name, GF_LOG_ERROR, EINVAL, - API_MSG_FETCH_VOLUUID_FAILED, "Unable to fetch " - "volume UUID"); - goto out; - } + if (gf_uuid_is_null(fs->vol_uuid)) { + gf_msg(THIS->name, GF_LOG_ERROR, EINVAL, API_MSG_FETCH_VOLUUID_FAILED, + "Unable to fetch " + "volume UUID"); + goto out; + } done: - if (!volid || !size) { - gf_msg_debug (THIS->name, 0, "volumeid/size is null"); - __GLFS_EXIT_FS; - return uuid_size; - } + if (!volid || !size) { + gf_msg_debug(THIS->name, 0, "volumeid/size is null"); + __GLFS_EXIT_FS; + return uuid_size; + } - if (size < uuid_size) { - gf_msg (THIS->name, GF_LOG_ERROR, ERANGE, API_MSG_INSUFF_SIZE, - "Insufficient size passed"); - errno = ERANGE; - goto out; - } + if (size < uuid_size) { + gf_msg(THIS->name, GF_LOG_ERROR, ERANGE, API_MSG_INSUFF_SIZE, + "Insufficient size passed"); + errno = ERANGE; + goto out; + } - memcpy (volid, fs->vol_uuid, uuid_size); + memcpy(volid, fs->vol_uuid, uuid_size); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; - return uuid_size; + return uuid_size; out: - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return -1; + return -1; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_get_volumeid, 3.5.0); int -glfs_get_volume_info (struct glfs *fs) +glfs_get_volume_info(struct glfs *fs) { - call_frame_t *frame = NULL; - glusterfs_ctx_t *ctx = NULL; - struct syncargs args = {0, }; - int ret = 0; - - ctx = fs->ctx; - frame = create_frame (THIS, ctx->pool); - if (!frame) { - gf_msg ("glfs", GF_LOG_ERROR, ENOMEM, - API_MSG_FRAME_CREAT_FAILED, - "failed to create the frame"); - ret = -1; - goto out; - } + call_frame_t *frame = NULL; + glusterfs_ctx_t *ctx = NULL; + struct syncargs args = { + 0, + }; + int ret = 0; - frame->local = &args; + ctx = fs->ctx; + frame = create_frame(THIS, ctx->pool); + if (!frame) { + gf_msg("glfs", GF_LOG_ERROR, ENOMEM, API_MSG_FRAME_CREAT_FAILED, + "failed to create the frame"); + ret = -1; + goto out; + } - __yawn ((&args)); + frame->local = &args; - ret = glfs_get_volume_info_rpc (frame, THIS, fs); - if (ret) - goto out; + __yawn((&args)); - __yield ((&args)); + ret = glfs_get_volume_info_rpc(frame, THIS, fs); + if (ret) + goto out; - frame->local = NULL; - STACK_DESTROY (frame->root); + __yield((&args)); + + frame->local = NULL; + STACK_DESTROY(frame->root); out: - return ret; + return ret; } int32_t -glfs_get_volume_info_rpc (call_frame_t *frame, xlator_t *this, - struct glfs *fs) +glfs_get_volume_info_rpc(call_frame_t *frame, xlator_t *this, struct glfs *fs) { - gf_get_volume_info_req req = {{0,}}; - int ret = 0; - glusterfs_ctx_t *ctx = NULL; - dict_t *dict = NULL; - int32_t flags = 0; - - if (!frame || !this || !fs) { - ret = -1; - goto out; - } - - ctx = fs->ctx; - - dict = dict_new (); - if (!dict) { - ret = -1; - goto out; - } - - if (fs->volname) { - ret = dict_set_str (dict, "volname", fs->volname); - if (ret) - goto out; - } - - // Set the flags for the fields which we are interested in - flags = (int32_t)GF_GET_VOLUME_UUID; //ctx->flags; - ret = dict_set_int32 (dict, "flags", flags); - if (ret) { - gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL, - API_MSG_DICT_SET_FAILED, "failed to set flags"); - goto out; - } - - ret = dict_allocate_and_serialize (dict, &req.dict.dict_val, - &req.dict.dict_len); - - - ret = mgmt_submit_request (&req, frame, ctx, &clnt_handshake_prog, - GF_HNDSK_GET_VOLUME_INFO, - mgmt_get_volinfo_cbk, - (xdrproc_t)xdr_gf_get_volume_info_req); + gf_get_volume_info_req req = {{ + 0, + }}; + int ret = 0; + glusterfs_ctx_t *ctx = NULL; + dict_t *dict = NULL; + int32_t flags = 0; + + if (!frame || !this || !fs) { + ret = -1; + goto out; + } + + ctx = fs->ctx; + + dict = dict_new(); + if (!dict) { + ret = -1; + goto out; + } + + if (fs->volname) { + ret = dict_set_str(dict, "volname", fs->volname); + if (ret) + goto out; + } + + // Set the flags for the fields which we are interested in + flags = (int32_t)GF_GET_VOLUME_UUID; // ctx->flags; + ret = dict_set_int32(dict, "flags", flags); + if (ret) { + gf_msg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_DICT_SET_FAILED, + "failed to set flags"); + goto out; + } + + ret = dict_allocate_and_serialize(dict, &req.dict.dict_val, + &req.dict.dict_len); + + ret = mgmt_submit_request(&req, frame, ctx, &clnt_handshake_prog, + GF_HNDSK_GET_VOLUME_INFO, mgmt_get_volinfo_cbk, + (xdrproc_t)xdr_gf_get_volume_info_req); out: - if (dict) { - dict_unref (dict); - } + if (dict) { + dict_unref(dict); + } - GF_FREE (req.dict.dict_val); + GF_FREE(req.dict.dict_val); - return ret; + return ret; } static int -glusterfs_oldvolfile_update (struct glfs *fs, char *volfile, ssize_t size) +glusterfs_oldvolfile_update(struct glfs *fs, char *volfile, ssize_t size) { - int ret = -1; - - pthread_mutex_lock (&fs->mutex); - - fs->oldvollen = size; - if (!fs->oldvolfile) { - fs->oldvolfile = CALLOC (1, size+1); - } else { - fs->oldvolfile = REALLOC (fs->oldvolfile, size+1); - } - - if (!fs->oldvolfile) { - fs->oldvollen = 0; - } else { - memcpy (fs->oldvolfile, volfile, size); - fs->oldvollen = size; - ret = 0; - } + int ret = -1; + + pthread_mutex_lock(&fs->mutex); + + fs->oldvollen = size; + if (!fs->oldvolfile) { + fs->oldvolfile = CALLOC(1, size + 1); + } else { + fs->oldvolfile = REALLOC(fs->oldvolfile, size + 1); + } + + if (!fs->oldvolfile) { + fs->oldvollen = 0; + } else { + memcpy(fs->oldvolfile, volfile, size); + fs->oldvollen = size; + ret = 0; + } - pthread_mutex_unlock (&fs->mutex); + pthread_mutex_unlock(&fs->mutex); - return ret; + return ret; } - int -glfs_mgmt_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count, - void *myframe) +glfs_mgmt_getspec_cbk(struct rpc_req *req, struct iovec *iov, int count, + void *myframe) { - gf_getspec_rsp rsp = {0,}; - call_frame_t *frame = NULL; - glusterfs_ctx_t *ctx = NULL; - int ret = 0; - ssize_t size = 0; - FILE *tmpfp = NULL; - int need_retry = 0; - struct glfs *fs = NULL; - dict_t *dict = NULL; - char *servers_list = NULL; - int tmp_fd = -1; - char template[] = "/tmp/gfapi.volfile.XXXXXX"; - - frame = myframe; - ctx = frame->this->ctx; - - if (!ctx) { - gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL, - API_MSG_INVALID_ENTRY, "NULL context"); - errno = EINVAL; - ret = -1; - goto out; - } - - fs = ((xlator_t *)ctx->master)->private; - - if (-1 == req->rpc_status) { - ret = -1; - need_retry = 1; - goto out; - } - - ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp); - if (ret < 0) { - gf_msg (frame->this->name, GF_LOG_ERROR, 0, - API_MSG_XDR_DECODE_FAILED, "XDR decoding error"); - ret = -1; - goto out; - } - - if (-1 == rsp.op_ret) { - gf_msg (frame->this->name, GF_LOG_ERROR, rsp.op_errno, - API_MSG_GET_VOLFILE_FAILED, - "failed to get the 'volume file' from server"); - ret = -1; - errno = rsp.op_errno; - goto out; - } - - if (!rsp.xdata.xdata_len) { - goto volfile; - } - - dict = dict_new (); - if (!dict) { - ret = -1; - errno = ENOMEM; - goto out; - } - - ret = dict_unserialize (rsp.xdata.xdata_val, rsp.xdata.xdata_len, - &dict); - if (ret) { - gf_log (frame->this->name, GF_LOG_ERROR, - "failed to unserialize xdata to dictionary"); - goto out; - } - dict->extra_stdfree = rsp.xdata.xdata_val; - - /* glusterd2 only */ - ret = dict_get_str (dict, "servers-list", &servers_list); - if (ret) { - goto volfile; - } - - gf_log (frame->this->name, GF_LOG_INFO, - "Received list of available volfile servers: %s", - servers_list); - - ret = gf_process_getspec_servers_list(&ctx->cmd_args, servers_list); - if (ret) { - gf_log (frame->this->name, GF_LOG_ERROR, - "Failed (%s) to process servers list: %s", - strerror (errno), servers_list); - } + gf_getspec_rsp rsp = { + 0, + }; + call_frame_t *frame = NULL; + glusterfs_ctx_t *ctx = NULL; + int ret = 0; + ssize_t size = 0; + FILE *tmpfp = NULL; + int need_retry = 0; + struct glfs *fs = NULL; + dict_t *dict = NULL; + char *servers_list = NULL; + int tmp_fd = -1; + char template[] = "/tmp/gfapi.volfile.XXXXXX"; + + frame = myframe; + ctx = frame->this->ctx; + + if (!ctx) { + gf_msg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY, + "NULL context"); + errno = EINVAL; + ret = -1; + goto out; + } + + fs = ((xlator_t *)ctx->master)->private; + + if (-1 == req->rpc_status) { + ret = -1; + need_retry = 1; + goto out; + } + + ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp); + if (ret < 0) { + gf_msg(frame->this->name, GF_LOG_ERROR, 0, API_MSG_XDR_DECODE_FAILED, + "XDR decoding error"); + ret = -1; + goto out; + } + + if (-1 == rsp.op_ret) { + gf_msg(frame->this->name, GF_LOG_ERROR, rsp.op_errno, + API_MSG_GET_VOLFILE_FAILED, + "failed to get the 'volume file' from server"); + ret = -1; + errno = rsp.op_errno; + goto out; + } + + if (!rsp.xdata.xdata_len) { + goto volfile; + } + + dict = dict_new(); + if (!dict) { + ret = -1; + errno = ENOMEM; + goto out; + } + + ret = dict_unserialize(rsp.xdata.xdata_val, rsp.xdata.xdata_len, &dict); + if (ret) { + gf_log(frame->this->name, GF_LOG_ERROR, + "failed to unserialize xdata to dictionary"); + goto out; + } + dict->extra_stdfree = rsp.xdata.xdata_val; + + /* glusterd2 only */ + ret = dict_get_str(dict, "servers-list", &servers_list); + if (ret) { + goto volfile; + } + + gf_log(frame->this->name, GF_LOG_INFO, + "Received list of available volfile servers: %s", servers_list); + + ret = gf_process_getspec_servers_list(&ctx->cmd_args, servers_list); + if (ret) { + gf_log(frame->this->name, GF_LOG_ERROR, + "Failed (%s) to process servers list: %s", strerror(errno), + servers_list); + } volfile: - ret = 0; - size = rsp.op_ret; - - if ((size == fs->oldvollen) && - (memcmp (fs->oldvolfile, rsp.spec, size) == 0)) { - gf_msg (frame->this->name, GF_LOG_INFO, 0, - API_MSG_VOLFILE_INFO, - "No change in volfile, continuing"); - goto out; - } - - /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */ - tmp_fd = mkstemp (template); - if (-1 == tmp_fd) { - ret = -1; - goto out; - } - - /* Calling unlink so that when the file is closed or program - * terminates the temporary file is deleted. - */ - ret = sys_unlink (template); - if (ret < 0) { - gf_msg (frame->this->name, GF_LOG_INFO, 0, API_MSG_VOLFILE_INFO, - "Unable to delete file: %s", template); - ret = 0; + ret = 0; + size = rsp.op_ret; + + if ((size == fs->oldvollen) && + (memcmp(fs->oldvolfile, rsp.spec, size) == 0)) { + gf_msg(frame->this->name, GF_LOG_INFO, 0, API_MSG_VOLFILE_INFO, + "No change in volfile, continuing"); + goto out; + } + + /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */ + tmp_fd = mkstemp(template); + if (-1 == tmp_fd) { + ret = -1; + goto out; + } + + /* Calling unlink so that when the file is closed or program + * terminates the temporary file is deleted. + */ + ret = sys_unlink(template); + if (ret < 0) { + gf_msg(frame->this->name, GF_LOG_INFO, 0, API_MSG_VOLFILE_INFO, + "Unable to delete file: %s", template); + ret = 0; + } + + tmpfp = fdopen(tmp_fd, "w+b"); + if (!tmpfp) { + ret = -1; + goto out; + } + + fwrite(rsp.spec, size, 1, tmpfp); + fflush(tmpfp); + if (ferror(tmpfp)) { + ret = -1; + goto out; + } + + /* Check if only options have changed. No need to reload the + * volfile if topology hasn't changed. + * glusterfs_volfile_reconfigure returns 3 possible return states + * return 0 =======> reconfiguration of options has succeeded + * return 1 =======> the graph has to be reconstructed and all the + * xlators should be inited return -1(or -ve) =======> Some Internal Error + * occurred during the operation + */ + + ret = gf_volfile_reconfigure(fs->oldvollen, tmpfp, fs->ctx, fs->oldvolfile); + if (ret == 0) { + gf_msg_debug("glusterfsd-mgmt", 0, + "No need to re-load " + "volfile, reconfigure done"); + ret = glusterfs_oldvolfile_update(fs, rsp.spec, size); + goto out; + } + + if (ret < 0) { + gf_msg_debug("glusterfsd-mgmt", 0, "Reconfigure failed !!"); + goto out; + } + + ret = glfs_process_volfp(fs, tmpfp); + /* tmpfp closed */ + tmpfp = NULL; + tmp_fd = -1; + if (ret) + goto out; + + ret = glusterfs_oldvolfile_update(fs, rsp.spec, size); +out: + STACK_DESTROY(frame->root); + + if (rsp.spec) + free(rsp.spec); + + if (dict) + dict_unref(dict); + + // Stop if server is running at an unsupported op-version + if (ENOTSUP == ret) { + gf_msg("mgmt", GF_LOG_ERROR, ENOTSUP, API_MSG_WRONG_OPVERSION, + "Server is operating at an op-version which is not " + "supported"); + errno = ENOTSUP; + glfs_init_done(fs, -1); + } + + if (ret && ctx && !ctx->active) { + /* Do it only for the first time */ + /* Failed to get the volume file, something wrong, + restart the process */ + gf_msg("glfs-mgmt", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY, + "failed to fetch volume file (key:%s)", + ctx->cmd_args.volfile_id); + if (!need_retry) { + if (!errno) + errno = EINVAL; + glfs_init_done(fs, -1); } + } - tmpfp = fdopen (tmp_fd, "w+b"); - if (!tmpfp) { - ret = -1; - goto out; - } + if (tmpfp) + fclose(tmpfp); + else if (tmp_fd != -1) + sys_close(tmp_fd); - fwrite (rsp.spec, size, 1, tmpfp); - fflush (tmpfp); - if (ferror (tmpfp)) { - ret = -1; - goto out; - } - - /* Check if only options have changed. No need to reload the - * volfile if topology hasn't changed. - * glusterfs_volfile_reconfigure returns 3 possible return states - * return 0 =======> reconfiguration of options has succeeded - * return 1 =======> the graph has to be reconstructed and all the xlators should be inited - * return -1(or -ve) =======> Some Internal Error occurred during the operation - */ - - ret = gf_volfile_reconfigure (fs->oldvollen, tmpfp, fs->ctx, - fs->oldvolfile); - if (ret == 0) { - gf_msg_debug ("glusterfsd-mgmt", 0, "No need to re-load " - "volfile, reconfigure done"); - ret = glusterfs_oldvolfile_update (fs, rsp.spec, size); - goto out; - } - - if (ret < 0) { - gf_msg_debug ("glusterfsd-mgmt", 0, "Reconfigure failed !!"); - goto out; - } - - ret = glfs_process_volfp (fs, tmpfp); - /* tmpfp closed */ - tmpfp = NULL; - tmp_fd = -1; - if (ret) - goto out; - - ret = glusterfs_oldvolfile_update (fs, rsp.spec, size); -out: - STACK_DESTROY (frame->root); - - if (rsp.spec) - free (rsp.spec); - - if (dict) - dict_unref (dict); - - // Stop if server is running at an unsupported op-version - if (ENOTSUP == ret) { - gf_msg ("mgmt", GF_LOG_ERROR, ENOTSUP, API_MSG_WRONG_OPVERSION, - "Server is operating at an op-version which is not " - "supported"); - errno = ENOTSUP; - glfs_init_done (fs, -1); - } - - if (ret && ctx && !ctx->active) { - /* Do it only for the first time */ - /* Failed to get the volume file, something wrong, - restart the process */ - gf_msg ("glfs-mgmt", GF_LOG_ERROR, EINVAL, - API_MSG_INVALID_ENTRY, - "failed to fetch volume file (key:%s)", - ctx->cmd_args.volfile_id); - if (!need_retry) { - if (!errno) - errno = EINVAL; - glfs_init_done (fs, -1); - } - } - - if (tmpfp) - fclose (tmpfp); - else if (tmp_fd != -1) - sys_close (tmp_fd); - - return 0; + return 0; } - int -glfs_volfile_fetch (struct glfs *fs) +glfs_volfile_fetch(struct glfs *fs) { - cmd_args_t *cmd_args = NULL; - gf_getspec_req req = {0, }; - int ret = 0; - call_frame_t *frame = NULL; - glusterfs_ctx_t *ctx = NULL; - dict_t *dict = NULL; - - ctx = fs->ctx; - cmd_args = &ctx->cmd_args; - - frame = create_frame (THIS, ctx->pool); - - req.key = cmd_args->volfile_id; - req.flags = 0; - - dict = dict_new (); - if (!dict) { - ret = -1; - goto out; - } - - // Set the supported min and max op-versions, so glusterd can make a - // decision - ret = dict_set_int32 (dict, "min-op-version", GD_OP_VERSION_MIN); - if (ret) { - gf_msg (THIS->name, GF_LOG_ERROR, EINVAL, - API_MSG_DICT_SET_FAILED, - "Failed to set min-op-version in request dict"); - goto out; - } - - ret = dict_set_int32 (dict, "max-op-version", GD_OP_VERSION_MAX); - if (ret) { - gf_msg (THIS->name, GF_LOG_ERROR, EINVAL, - API_MSG_DICT_SET_FAILED, - "Failed to set max-op-version in request dict"); - goto out; - } - - /* Ask for a list of volfile (glusterd2 only) servers */ - if (GF_CLIENT_PROCESS == ctx->process_mode) { - req.flags = req.flags | GF_GETSPEC_FLAG_SERVERS_LIST; - } - - ret = dict_allocate_and_serialize (dict, &req.xdata.xdata_val, - &req.xdata.xdata_len); - if (ret < 0) { - gf_msg (THIS->name, GF_LOG_ERROR, 0, - API_MSG_DICT_SERIALIZE_FAILED, - "Failed to serialize dictionary"); - goto out; - } - - ret = mgmt_submit_request (&req, frame, ctx, &clnt_handshake_prog, - GF_HNDSK_GETSPEC, glfs_mgmt_getspec_cbk, - (xdrproc_t)xdr_gf_getspec_req); + cmd_args_t *cmd_args = NULL; + gf_getspec_req req = { + 0, + }; + int ret = 0; + call_frame_t *frame = NULL; + glusterfs_ctx_t *ctx = NULL; + dict_t *dict = NULL; + + ctx = fs->ctx; + cmd_args = &ctx->cmd_args; + + frame = create_frame(THIS, ctx->pool); + + req.key = cmd_args->volfile_id; + req.flags = 0; + + dict = dict_new(); + if (!dict) { + ret = -1; + goto out; + } + + // Set the supported min and max op-versions, so glusterd can make a + // decision + ret = dict_set_int32(dict, "min-op-version", GD_OP_VERSION_MIN); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, EINVAL, API_MSG_DICT_SET_FAILED, + "Failed to set min-op-version in request dict"); + goto out; + } + + ret = dict_set_int32(dict, "max-op-version", GD_OP_VERSION_MAX); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, EINVAL, API_MSG_DICT_SET_FAILED, + "Failed to set max-op-version in request dict"); + goto out; + } + + /* Ask for a list of volfile (glusterd2 only) servers */ + if (GF_CLIENT_PROCESS == ctx->process_mode) { + req.flags = req.flags | GF_GETSPEC_FLAG_SERVERS_LIST; + } + + ret = dict_allocate_and_serialize(dict, &req.xdata.xdata_val, + &req.xdata.xdata_len); + if (ret < 0) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, API_MSG_DICT_SERIALIZE_FAILED, + "Failed to serialize dictionary"); + goto out; + } + + ret = mgmt_submit_request(&req, frame, ctx, &clnt_handshake_prog, + GF_HNDSK_GETSPEC, glfs_mgmt_getspec_cbk, + (xdrproc_t)xdr_gf_getspec_req); out: - if (req.xdata.xdata_val) - GF_FREE(req.xdata.xdata_val); - if (dict) - dict_unref (dict); + if (req.xdata.xdata_val) + GF_FREE(req.xdata.xdata_val); + if (dict) + dict_unref(dict); - return ret; + return ret; } - static int -mgmt_rpc_notify (struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event, - void *data) +mgmt_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event, + void *data) { - xlator_t *this = NULL; - glusterfs_ctx_t *ctx = NULL; - server_cmdline_t *server = NULL; - rpc_transport_t *rpc_trans = NULL; - struct glfs *fs = NULL; - int ret = 0; - struct dnscache6 *dnscache = NULL; - - this = mydata; - rpc_trans = rpc->conn.trans; - - ctx = this->ctx; - if (!ctx) - goto out; - - fs = ((xlator_t *)ctx->master)->private; - - switch (event) { - case RPC_CLNT_DISCONNECT: - if (!ctx->active) { - if (rpc_trans->connect_failed) - gf_msg ("glfs-mgmt", GF_LOG_ERROR, 0, - API_MSG_REMOTE_HOST_CONN_FAILED, - "failed to connect to remote-host: %s", - ctx->cmd_args.volfile_server); - else - gf_msg ("glfs-mgmt", GF_LOG_INFO, 0, - API_MSG_REMOTE_HOST_CONN_FAILED, - "disconnected from remote-host: %s", - ctx->cmd_args.volfile_server); - - if (!rpc->disabled) { - /* - * Check if dnscache is exhausted for current server - * and continue until cache is exhausted - */ - dnscache = rpc_trans->dnscache; - if (dnscache && dnscache->next) { - break; - } - } - server = ctx->cmd_args.curr_server; - if (server->list.next == &ctx->cmd_args.volfile_servers) { - errno = ENOTCONN; - gf_msg ("glfs-mgmt", GF_LOG_INFO, ENOTCONN, - API_MSG_VOLFILE_SERVER_EXHAUST, - "Exhausted all volfile servers"); - glfs_init_done (fs, -1); - break; - } - server = list_entry (server->list.next, typeof(*server), - list); - ctx->cmd_args.curr_server = server; - ctx->cmd_args.volfile_server_port = server->port; - ctx->cmd_args.volfile_server = server->volfile_server; - ctx->cmd_args.volfile_server_transport = server->transport; - - ret = dict_set_str (rpc_trans->options, - "transport-type", - server->transport); - if (ret != 0) { - gf_msg ("glfs-mgmt", GF_LOG_ERROR, ENOTCONN, - API_MSG_DICT_SET_FAILED, - "failed to set transport-type: %s", - server->transport); - errno = ENOTCONN; - glfs_init_done (fs, -1); - break; - } - - if (strcmp(server->transport, "unix") == 0) { - ret = dict_set_str (rpc_trans->options, - "transport.socket.connect-path", - server->volfile_server); - if (ret != 0) { - gf_msg ("glfs-mgmt", GF_LOG_ERROR, - ENOTCONN, - API_MSG_DICT_SET_FAILED, - "failed to set socket.connect-path: %s", - server->volfile_server); - errno = ENOTCONN; - glfs_init_done (fs, -1); - break; - } - /* delete the remote-host and remote-port keys - * in case they were set while looping through - * list of volfile servers previously - */ - dict_del (rpc_trans->options, "remote-host"); - dict_del (rpc_trans->options, "remote-port"); - } else { - ret = dict_set_int32 (rpc_trans->options, - "remote-port", - server->port); - if (ret != 0) { - gf_msg ("glfs-mgmt", GF_LOG_ERROR, - ENOTCONN, - API_MSG_DICT_SET_FAILED, - "failed to set remote-port: %d", - server->port); - errno = ENOTCONN; - glfs_init_done (fs, -1); - break; - } - - ret = dict_set_str (rpc_trans->options, - "remote-host", - server->volfile_server); - if (ret != 0) { - gf_msg ("glfs-mgmt", GF_LOG_ERROR, - ENOTCONN, - API_MSG_DICT_SET_FAILED, - "failed to set remote-host: %s", - server->volfile_server); - errno = ENOTCONN; - glfs_init_done (fs, -1); - break; - } - /* delete the "transport.socket.connect-path" - * key in case if it was set while looping - * through list of volfile servers previously - */ - dict_del (rpc_trans->options, - "transport.socket.connect-path"); - } - - gf_msg ("glfs-mgmt", GF_LOG_INFO, 0, - API_MSG_VOLFILE_CONNECTING, - "connecting to next volfile server %s" - " at port %d with transport: %s", - server->volfile_server, server->port, - server->transport); + xlator_t *this = NULL; + glusterfs_ctx_t *ctx = NULL; + server_cmdline_t *server = NULL; + rpc_transport_t *rpc_trans = NULL; + struct glfs *fs = NULL; + int ret = 0; + struct dnscache6 *dnscache = NULL; + + this = mydata; + rpc_trans = rpc->conn.trans; + + ctx = this->ctx; + if (!ctx) + goto out; + + fs = ((xlator_t *)ctx->master)->private; + + switch (event) { + case RPC_CLNT_DISCONNECT: + if (!ctx->active) { + if (rpc_trans->connect_failed) + gf_msg("glfs-mgmt", GF_LOG_ERROR, 0, + API_MSG_REMOTE_HOST_CONN_FAILED, + "failed to connect to remote-host: %s", + ctx->cmd_args.volfile_server); + else + gf_msg("glfs-mgmt", GF_LOG_INFO, 0, + API_MSG_REMOTE_HOST_CONN_FAILED, + "disconnected from remote-host: %s", + ctx->cmd_args.volfile_server); + + if (!rpc->disabled) { + /* + * Check if dnscache is exhausted for current server + * and continue until cache is exhausted + */ + dnscache = rpc_trans->dnscache; + if (dnscache && dnscache->next) { + break; + } } - break; - case RPC_CLNT_CONNECT: - ret = glfs_volfile_fetch (fs); - if (ret && (ctx->active == NULL)) { - /* Do it only for the first time */ - /* Exit the process.. there are some wrong options */ - gf_msg ("glfs-mgmt", GF_LOG_ERROR, EINVAL, - API_MSG_INVALID_ENTRY, - "failed to fetch volume file (key:%s)", - ctx->cmd_args.volfile_id); - errno = EINVAL; - glfs_init_done (fs, -1); + server = ctx->cmd_args.curr_server; + if (server->list.next == &ctx->cmd_args.volfile_servers) { + errno = ENOTCONN; + gf_msg("glfs-mgmt", GF_LOG_INFO, ENOTCONN, + API_MSG_VOLFILE_SERVER_EXHAUST, + "Exhausted all volfile servers"); + glfs_init_done(fs, -1); + break; + } + server = list_entry(server->list.next, typeof(*server), list); + ctx->cmd_args.curr_server = server; + ctx->cmd_args.volfile_server_port = server->port; + ctx->cmd_args.volfile_server = server->volfile_server; + ctx->cmd_args.volfile_server_transport = server->transport; + + ret = dict_set_str(rpc_trans->options, "transport-type", + server->transport); + if (ret != 0) { + gf_msg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN, + API_MSG_DICT_SET_FAILED, + "failed to set transport-type: %s", + server->transport); + errno = ENOTCONN; + glfs_init_done(fs, -1); + break; } - break; - default: - break; - } + if (strcmp(server->transport, "unix") == 0) { + ret = dict_set_str(rpc_trans->options, + "transport.socket.connect-path", + server->volfile_server); + if (ret != 0) { + gf_msg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN, + API_MSG_DICT_SET_FAILED, + "failed to set socket.connect-path: %s", + server->volfile_server); + errno = ENOTCONN; + glfs_init_done(fs, -1); + break; + } + /* delete the remote-host and remote-port keys + * in case they were set while looping through + * list of volfile servers previously + */ + dict_del(rpc_trans->options, "remote-host"); + dict_del(rpc_trans->options, "remote-port"); + } else { + ret = dict_set_int32(rpc_trans->options, "remote-port", + server->port); + if (ret != 0) { + gf_msg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN, + API_MSG_DICT_SET_FAILED, + "failed to set remote-port: %d", server->port); + errno = ENOTCONN; + glfs_init_done(fs, -1); + break; + } + + ret = dict_set_str(rpc_trans->options, "remote-host", + server->volfile_server); + if (ret != 0) { + gf_msg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN, + API_MSG_DICT_SET_FAILED, + "failed to set remote-host: %s", + server->volfile_server); + errno = ENOTCONN; + glfs_init_done(fs, -1); + break; + } + /* delete the "transport.socket.connect-path" + * key in case if it was set while looping + * through list of volfile servers previously + */ + dict_del(rpc_trans->options, + "transport.socket.connect-path"); + } + + gf_msg("glfs-mgmt", GF_LOG_INFO, 0, API_MSG_VOLFILE_CONNECTING, + "connecting to next volfile server %s" + " at port %d with transport: %s", + server->volfile_server, server->port, server->transport); + } + break; + case RPC_CLNT_CONNECT: + ret = glfs_volfile_fetch(fs); + if (ret && (ctx->active == NULL)) { + /* Do it only for the first time */ + /* Exit the process.. there are some wrong options */ + gf_msg("glfs-mgmt", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY, + "failed to fetch volume file (key:%s)", + ctx->cmd_args.volfile_id); + errno = EINVAL; + glfs_init_done(fs, -1); + } + + break; + default: + break; + } out: - return 0; + return 0; } - int -glusterfs_mgmt_notify (int32_t op, void *data, ...) +glusterfs_mgmt_notify(int32_t op, void *data, ...) { - int ret = 0; + int ret = 0; - switch (op) - { - case GF_EN_DEFRAG_STATUS: - break; + switch (op) { + case GF_EN_DEFRAG_STATUS: + break; - default: - break; - } + default: + break; + } - return ret; + return ret; } - int -glfs_mgmt_init (struct glfs *fs) +glfs_mgmt_init(struct glfs *fs) { - cmd_args_t *cmd_args = NULL; - struct rpc_clnt *rpc = NULL; - dict_t *options = NULL; - int ret = -1; - int port = GF_DEFAULT_BASE_PORT; - char *host = NULL; - glusterfs_ctx_t *ctx = NULL; - - ctx = fs->ctx; - cmd_args = &ctx->cmd_args; - - if (ctx->mgmt) - return 0; - - if (cmd_args->volfile_server_port) - port = cmd_args->volfile_server_port; - - if (cmd_args->volfile_server) { - host = cmd_args->volfile_server; - } else if (cmd_args->volfile_server_transport && - !strcmp (cmd_args->volfile_server_transport, "unix")) { - host = DEFAULT_GLUSTERD_SOCKFILE; - } else { - host = "localhost"; - } - - if (cmd_args->volfile_server_transport && - !strcmp (cmd_args->volfile_server_transport, "unix")) { - ret = rpc_transport_unix_options_build (&options, host, 0); - } else { - ret = rpc_transport_inet_options_build (&options, host, port); - } - - if (ret) - goto out; - - if (sys_access (SECURE_ACCESS_FILE, F_OK) == 0) { - ctx->secure_mgmt = 1; - ctx->ssl_cert_depth = glusterfs_read_secure_access_file (); - } - - rpc = rpc_clnt_new (options, THIS, THIS->name, 8); - if (!rpc) { - ret = -1; - gf_msg (THIS->name, GF_LOG_WARNING, 0, - API_MSG_CREATE_RPC_CLIENT_FAILED, - "failed to create rpc clnt"); - goto out; - } - - ret = rpc_clnt_register_notify (rpc, mgmt_rpc_notify, THIS); - if (ret) { - gf_msg (THIS->name, GF_LOG_WARNING, 0, - API_MSG_REG_NOTIFY_FUNC_FAILED, - "failed to register notify function"); - goto out; - } - - ret = rpcclnt_cbk_program_register (rpc, &mgmt_cbk_prog, THIS); - if (ret) { - gf_msg (THIS->name, GF_LOG_WARNING, 0, - API_MSG_REG_CBK_FUNC_FAILED, - "failed to register callback function"); - goto out; - } - - ctx->notify = glusterfs_mgmt_notify; - - /* This value should be set before doing the 'rpc_clnt_start()' as - the notify function uses this variable */ - ctx->mgmt = rpc; - - ret = rpc_clnt_start (rpc); + cmd_args_t *cmd_args = NULL; + struct rpc_clnt *rpc = NULL; + dict_t *options = NULL; + int ret = -1; + int port = GF_DEFAULT_BASE_PORT; + char *host = NULL; + glusterfs_ctx_t *ctx = NULL; + + ctx = fs->ctx; + cmd_args = &ctx->cmd_args; + + if (ctx->mgmt) + return 0; + + if (cmd_args->volfile_server_port) + port = cmd_args->volfile_server_port; + + if (cmd_args->volfile_server) { + host = cmd_args->volfile_server; + } else if (cmd_args->volfile_server_transport && + !strcmp(cmd_args->volfile_server_transport, "unix")) { + host = DEFAULT_GLUSTERD_SOCKFILE; + } else { + host = "localhost"; + } + + if (cmd_args->volfile_server_transport && + !strcmp(cmd_args->volfile_server_transport, "unix")) { + ret = rpc_transport_unix_options_build(&options, host, 0); + } else { + ret = rpc_transport_inet_options_build(&options, host, port); + } + + if (ret) + goto out; + + if (sys_access(SECURE_ACCESS_FILE, F_OK) == 0) { + ctx->secure_mgmt = 1; + ctx->ssl_cert_depth = glusterfs_read_secure_access_file(); + } + + rpc = rpc_clnt_new(options, THIS, THIS->name, 8); + if (!rpc) { + ret = -1; + gf_msg(THIS->name, GF_LOG_WARNING, 0, API_MSG_CREATE_RPC_CLIENT_FAILED, + "failed to create rpc clnt"); + goto out; + } + + ret = rpc_clnt_register_notify(rpc, mgmt_rpc_notify, THIS); + if (ret) { + gf_msg(THIS->name, GF_LOG_WARNING, 0, API_MSG_REG_NOTIFY_FUNC_FAILED, + "failed to register notify function"); + goto out; + } + + ret = rpcclnt_cbk_program_register(rpc, &mgmt_cbk_prog, THIS); + if (ret) { + gf_msg(THIS->name, GF_LOG_WARNING, 0, API_MSG_REG_CBK_FUNC_FAILED, + "failed to register callback function"); + goto out; + } + + ctx->notify = glusterfs_mgmt_notify; + + /* This value should be set before doing the 'rpc_clnt_start()' as + the notify function uses this variable */ + ctx->mgmt = rpc; + + ret = rpc_clnt_start(rpc); out: - return ret; + return ret; } diff --git a/api/src/glfs-resolve.c b/api/src/glfs-resolve.c index 0c4b9651bd4..34794b605e4 100644 --- a/api/src/glfs-resolve.c +++ b/api/src/glfs-resolve.c @@ -8,7 +8,6 @@ cases as published by the Free Software Foundation. */ - #include #include #include @@ -28,46 +27,47 @@ #include "inode.h" #include "glfs-internal.h" -#define graphid_str(subvol) (uuid_utoa((unsigned char *)subvol->graph->graph_uuid)) +#define graphid_str(subvol) \ + (uuid_utoa((unsigned char *)subvol->graph->graph_uuid)) int -glfs_first_lookup_safe (xlator_t *subvol) +glfs_first_lookup_safe(xlator_t *subvol) { - loc_t loc = {0, }; - int ret = -1; + loc_t loc = { + 0, + }; + int ret = -1; - loc.inode = subvol->itable->root; - memset (loc.gfid, 0, 16); - loc.gfid[15] = 1; - loc.path = "/"; - loc.name = ""; + loc.inode = subvol->itable->root; + memset(loc.gfid, 0, 16); + loc.gfid[15] = 1; + loc.path = "/"; + loc.name = ""; - ret = syncop_lookup (subvol, &loc, 0, 0, 0, 0); - DECODE_SYNCOP_ERR (ret); + ret = syncop_lookup(subvol, &loc, 0, 0, 0, 0); + DECODE_SYNCOP_ERR(ret); - gf_msg_debug (subvol->name, 0, "first lookup complete %d", ret); + gf_msg_debug(subvol->name, 0, "first lookup complete %d", ret); - return ret; + return ret; } - int -__glfs_first_lookup (struct glfs *fs, xlator_t *subvol) +__glfs_first_lookup(struct glfs *fs, xlator_t *subvol) { - int ret = -1; - - fs->migration_in_progress = 1; - pthread_mutex_unlock (&fs->mutex); - { - ret = glfs_first_lookup_safe (subvol); - } - pthread_mutex_lock (&fs->mutex); - fs->migration_in_progress = 0; - pthread_cond_broadcast (&fs->cond); - - return ret; + int ret = -1; + + fs->migration_in_progress = 1; + pthread_mutex_unlock(&fs->mutex); + { + ret = glfs_first_lookup_safe(subvol); + } + pthread_mutex_lock(&fs->mutex); + fs->migration_in_progress = 0; + pthread_cond_broadcast(&fs->cond); + + return ret; } - /** * We have to check if need_lookup flag is set in both old and the new inodes. * If its set in oldinode, then directly go ahead and do an explicit lookup. @@ -76,842 +76,819 @@ __glfs_first_lookup (struct glfs *fs, xlator_t *subvol) * below xlators can set their respective contexts. */ inode_t * -glfs_refresh_inode_safe (xlator_t *subvol, inode_t *oldinode, - gf_boolean_t need_lookup) +glfs_refresh_inode_safe(xlator_t *subvol, inode_t *oldinode, + gf_boolean_t need_lookup) { - loc_t loc = {0, }; - int ret = -1; - struct iatt iatt = {0, }; - inode_t *newinode = NULL; - gf_boolean_t lookup_needed = _gf_false; - uint64_t ctx_value = LOOKUP_NOT_NEEDED; - - - if (!oldinode) - return NULL; - - if (!need_lookup && oldinode->table->xl == subvol) - return inode_ref (oldinode); - - newinode = inode_find (subvol->itable, oldinode->gfid); - if (!need_lookup && newinode) { - - lookup_needed = inode_needs_lookup (newinode, THIS); - if (!lookup_needed) - return newinode; - } - - gf_uuid_copy (loc.gfid, oldinode->gfid); - if (!newinode) - loc.inode = inode_new (subvol->itable); - else - loc.inode = newinode; - - if (!loc.inode) - return NULL; - - ret = syncop_lookup (subvol, &loc, &iatt, 0, 0, 0); - DECODE_SYNCOP_ERR (ret); - - if (ret) { - gf_msg (subvol->name, GF_LOG_WARNING, errno, - API_MSG_INODE_REFRESH_FAILED, - "inode refresh of %s failed: %s", - uuid_utoa (oldinode->gfid), strerror (errno)); - loc_wipe (&loc); - return NULL; - } - - newinode = inode_link (loc.inode, 0, 0, &iatt); - if (newinode) { - if (newinode == loc.inode) - inode_ctx_set (newinode, THIS, &ctx_value); - inode_lookup (newinode); - } else { - gf_msg (subvol->name, GF_LOG_WARNING, errno, - API_MSG_INODE_LINK_FAILED, - "inode linking of %s failed", - uuid_utoa ((unsigned char *)&iatt.ia_gfid)); - } - - loc_wipe (&loc); - - return newinode; + loc_t loc = { + 0, + }; + int ret = -1; + struct iatt iatt = { + 0, + }; + inode_t *newinode = NULL; + gf_boolean_t lookup_needed = _gf_false; + uint64_t ctx_value = LOOKUP_NOT_NEEDED; + + if (!oldinode) + return NULL; + + if (!need_lookup && oldinode->table->xl == subvol) + return inode_ref(oldinode); + + newinode = inode_find(subvol->itable, oldinode->gfid); + if (!need_lookup && newinode) { + lookup_needed = inode_needs_lookup(newinode, THIS); + if (!lookup_needed) + return newinode; + } + + gf_uuid_copy(loc.gfid, oldinode->gfid); + if (!newinode) + loc.inode = inode_new(subvol->itable); + else + loc.inode = newinode; + + if (!loc.inode) + return NULL; + + ret = syncop_lookup(subvol, &loc, &iatt, 0, 0, 0); + DECODE_SYNCOP_ERR(ret); + + if (ret) { + gf_msg(subvol->name, GF_LOG_WARNING, errno, + API_MSG_INODE_REFRESH_FAILED, "inode refresh of %s failed: %s", + uuid_utoa(oldinode->gfid), strerror(errno)); + loc_wipe(&loc); + return NULL; + } + + newinode = inode_link(loc.inode, 0, 0, &iatt); + if (newinode) { + if (newinode == loc.inode) + inode_ctx_set(newinode, THIS, &ctx_value); + inode_lookup(newinode); + } else { + gf_msg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED, + "inode linking of %s failed", + uuid_utoa((unsigned char *)&iatt.ia_gfid)); + } + + loc_wipe(&loc); + + return newinode; } - inode_t * -__glfs_refresh_inode (struct glfs *fs, xlator_t *subvol, inode_t *inode, - gf_boolean_t need_lookup) +__glfs_refresh_inode(struct glfs *fs, xlator_t *subvol, inode_t *inode, + gf_boolean_t need_lookup) { - inode_t *newinode = NULL; - - fs->migration_in_progress = 1; - pthread_mutex_unlock (&fs->mutex); - { - newinode = glfs_refresh_inode_safe (subvol, inode, need_lookup); - } - pthread_mutex_lock (&fs->mutex); - fs->migration_in_progress = 0; - pthread_cond_broadcast (&fs->cond); - - return newinode; + inode_t *newinode = NULL; + + fs->migration_in_progress = 1; + pthread_mutex_unlock(&fs->mutex); + { + newinode = glfs_refresh_inode_safe(subvol, inode, need_lookup); + } + pthread_mutex_lock(&fs->mutex); + fs->migration_in_progress = 0; + pthread_cond_broadcast(&fs->cond); + + return newinode; } int -priv_glfs_loc_touchup (loc_t *loc) +priv_glfs_loc_touchup(loc_t *loc) { - int ret = 0; + int ret = 0; - ret = loc_touchup (loc, loc->name); - if (ret < 0) { - errno = -ret; - ret = -1; - } + ret = loc_touchup(loc, loc->name); + if (ret < 0) { + errno = -ret; + ret = -1; + } - return ret; + return ret; } GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_loc_touchup, 3.4.0); int -glfs_resolve_symlink (struct glfs *fs, xlator_t *subvol, inode_t *inode, - char **lpath) +glfs_resolve_symlink(struct glfs *fs, xlator_t *subvol, inode_t *inode, + char **lpath) { - loc_t loc = {0, }; - char *path = NULL; - char *rpath = NULL; - int ret = -1; - - loc.inode = inode_ref (inode); - gf_uuid_copy (loc.gfid, inode->gfid); - ret = inode_path (inode, NULL, &rpath); - if (ret < 0) - goto out; - loc.path = rpath; - - ret = syncop_readlink (subvol, &loc, &path, 4096, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - - if (ret < 0) - goto out; - - if (lpath) - *lpath = path; + loc_t loc = { + 0, + }; + char *path = NULL; + char *rpath = NULL; + int ret = -1; + + loc.inode = inode_ref(inode); + gf_uuid_copy(loc.gfid, inode->gfid); + ret = inode_path(inode, NULL, &rpath); + if (ret < 0) + goto out; + loc.path = rpath; + + ret = syncop_readlink(subvol, &loc, &path, 4096, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + + if (ret < 0) + goto out; + + if (lpath) + *lpath = path; out: - loc_wipe (&loc); - return ret; + loc_wipe(&loc); + return ret; } - int -glfs_resolve_base (struct glfs *fs, xlator_t *subvol, inode_t *inode, - struct iatt *iatt) +glfs_resolve_base(struct glfs *fs, xlator_t *subvol, inode_t *inode, + struct iatt *iatt) { - loc_t loc = {0, }; - int ret = -1; - char *path = NULL; - - loc.inode = inode_ref (inode); - gf_uuid_copy (loc.gfid, inode->gfid); - - ret = inode_path (loc.inode, NULL, &path); - loc.path = path; - if (ret < 0) - goto out; - - ret = syncop_lookup (subvol, &loc, iatt, NULL, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + loc_t loc = { + 0, + }; + int ret = -1; + char *path = NULL; + + loc.inode = inode_ref(inode); + gf_uuid_copy(loc.gfid, inode->gfid); + + ret = inode_path(loc.inode, NULL, &path); + loc.path = path; + if (ret < 0) + goto out; + + ret = syncop_lookup(subvol, &loc, iatt, NULL, NULL, NULL); + DECODE_SYNCOP_ERR(ret); out: - loc_wipe (&loc); + loc_wipe(&loc); - return ret; + return ret; } /* * This function can be used to call named lookup on root. * If you use glfs_resolve_base, that will be a nameless lookup. */ static int -glfs_resolve_root (struct glfs *fs, xlator_t *subvol, inode_t *inode, - struct iatt *iatt) +glfs_resolve_root(struct glfs *fs, xlator_t *subvol, inode_t *inode, + struct iatt *iatt) { - loc_t loc = {0, }; - int ret = -1; - char *path = NULL; - - loc.inode = inode_ref (inode); - - ret = inode_path (loc.inode, ".", &path); - loc.path = path; - loc.name = "."; - /* Having a value in loc.name will help to bypass md-cache check for - * nameless lookup. - * TODO: Re-visit on nameless lookup and md-cache. - * Github issue : https://github.com/gluster/glusterfs/issues/232 - */ - loc.parent = inode_ref (inode); - if (ret < 0) - goto out; - - ret = syncop_lookup (subvol, &loc, iatt, NULL, NULL, NULL); - DECODE_SYNCOP_ERR (ret); + loc_t loc = { + 0, + }; + int ret = -1; + char *path = NULL; + + loc.inode = inode_ref(inode); + + ret = inode_path(loc.inode, ".", &path); + loc.path = path; + loc.name = "."; + /* Having a value in loc.name will help to bypass md-cache check for + * nameless lookup. + * TODO: Re-visit on nameless lookup and md-cache. + * Github issue : https://github.com/gluster/glusterfs/issues/232 + */ + loc.parent = inode_ref(inode); + if (ret < 0) + goto out; + + ret = syncop_lookup(subvol, &loc, iatt, NULL, NULL, NULL); + DECODE_SYNCOP_ERR(ret); out: - loc_wipe (&loc); + loc_wipe(&loc); - return ret; + return ret; } inode_t * -glfs_resolve_component (struct glfs *fs, xlator_t *subvol, inode_t *parent, - const char *component, struct iatt *iatt, - int force_lookup) +glfs_resolve_component(struct glfs *fs, xlator_t *subvol, inode_t *parent, + const char *component, struct iatt *iatt, + int force_lookup) { - loc_t loc = {0, }; - inode_t *inode = NULL; - inode_t *temp_parent = NULL; - int reval = 0; - int ret = -1; - int glret = -1; - struct iatt ciatt = {0, }; - uuid_t gfid; - dict_t *xattr_req = NULL; - uint64_t ctx_value = LOOKUP_NOT_NEEDED; - - loc.parent = inode_ref (parent); - gf_uuid_copy (loc.pargfid, parent->gfid); - - if (__is_root_gfid (parent->gfid) && - ((strcmp (component, ".") == 0) || - (strcmp (component, "..") == 0) || - (strcmp (component, "") == 0))) { - if (!force_lookup) { - inode = inode_ref (parent); - } else { - ret = glfs_resolve_root (fs, subvol, parent, &ciatt); - if (!ret) - inode = inode_ref (parent); - } - goto found; + loc_t loc = { + 0, + }; + inode_t *inode = NULL; + inode_t *temp_parent = NULL; + int reval = 0; + int ret = -1; + int glret = -1; + struct iatt ciatt = { + 0, + }; + uuid_t gfid; + dict_t *xattr_req = NULL; + uint64_t ctx_value = LOOKUP_NOT_NEEDED; + + loc.parent = inode_ref(parent); + gf_uuid_copy(loc.pargfid, parent->gfid); + + if (__is_root_gfid(parent->gfid) && + ((strcmp(component, ".") == 0) || (strcmp(component, "..") == 0) || + (strcmp(component, "") == 0))) { + if (!force_lookup) { + inode = inode_ref(parent); + } else { + ret = glfs_resolve_root(fs, subvol, parent, &ciatt); + if (!ret) + inode = inode_ref(parent); + } + goto found; + } + /* * + * if the component name is either "." or "..", it will try to + * resolve that if inode has a proper parent (named lookup). + * + * Below condition works like this + * + * Example 1 : + * Path /out_dir/dir/in_dir/. + * In put values : + * parent = in_dir + * component : "." + * + * Out put values: + * parent : dir + * component : "in_dir" + * + * Example 2 : + * Path /out_dir/dir/in_dir/.. + * In put values : + * parent = in_dir + * component : ".." + * + * Out put values: + * parent : output_dir + * component : "dir" + * + * In case of nameless lookup, both "." and ".." retained + */ + + if (strcmp(component, ".") == 0) { + loc.inode = inode_ref(parent); + temp_parent = inode_parent(loc.inode, 0, 0); + if (temp_parent) { + inode_unref(loc.parent); + loc.parent = temp_parent; + inode_find_directory_name(loc.inode, &loc.name); } - /* * - * if the component name is either "." or "..", it will try to - * resolve that if inode has a proper parent (named lookup). - * - * Below condition works like this - * - * Example 1 : - * Path /out_dir/dir/in_dir/. - * In put values : - * parent = in_dir - * component : "." - * - * Out put values: - * parent : dir - * component : "in_dir" - * - * Example 2 : - * Path /out_dir/dir/in_dir/.. - * In put values : - * parent = in_dir - * component : ".." - * - * Out put values: - * parent : output_dir - * component : "dir" - * - * In case of nameless lookup, both "." and ".." retained - */ - if (strcmp (component, ".") == 0) { - loc.inode = inode_ref (parent); - temp_parent = inode_parent (loc.inode, 0, 0); - if (temp_parent) { - inode_unref (loc.parent); - loc.parent = temp_parent; - inode_find_directory_name (loc.inode, &loc.name); - } + } else if (strcmp(component, "..") == 0) { + loc.inode = inode_parent(parent, 0, 0); + if (loc.inode) { + temp_parent = inode_parent(loc.inode, 0, 0); + if (temp_parent) { + inode_unref(loc.parent); + loc.parent = temp_parent; + inode_find_directory_name(loc.inode, &loc.name); + } else if (__is_root_gfid(loc.inode->gfid)) { + inode_unref(loc.parent); + loc.parent = inode_ref(loc.inode); + loc.name = ""; + } else { + inode_unref(loc.inode); + loc.inode = NULL; + } + } + } else + loc.inode = inode_grep(parent->table, parent, component); - } else if (strcmp (component, "..") == 0) { - loc.inode = inode_parent (parent, 0, 0); - if (loc.inode) { - temp_parent = inode_parent (loc.inode, 0, 0); - if (temp_parent) { - inode_unref (loc.parent); - loc.parent = temp_parent; - inode_find_directory_name (loc.inode, &loc.name); - } else if (__is_root_gfid (loc.inode->gfid)) { - inode_unref (loc.parent); - loc.parent = inode_ref (loc.inode); - loc.name = ""; - } else { - inode_unref (loc.inode); - loc.inode = NULL; - } + if (!loc.name) + loc.name = component; - } - } else - loc.inode = inode_grep (parent->table, parent, component); - - if (!loc.name) - loc.name = component; - - if (loc.inode) { - gf_uuid_copy (loc.gfid, loc.inode->gfid); - reval = 1; - - if (!(force_lookup || inode_needs_lookup (loc.inode, THIS))) { - inode = inode_ref (loc.inode); - goto found; - } - } else { - gf_uuid_generate (gfid); - loc.inode = inode_new (parent->table); - if (!loc.inode) { - errno = ENOMEM; - goto out; - } + if (loc.inode) { + gf_uuid_copy(loc.gfid, loc.inode->gfid); + reval = 1; - xattr_req = dict_new (); - if (!xattr_req) { - errno = ENOMEM; - goto out; - } + if (!(force_lookup || inode_needs_lookup(loc.inode, THIS))) { + inode = inode_ref(loc.inode); + goto found; + } + } else { + gf_uuid_generate(gfid); + loc.inode = inode_new(parent->table); + if (!loc.inode) { + errno = ENOMEM; + goto out; + } - ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true); - if (ret) { - errno = ENOMEM; - goto out; - } + xattr_req = dict_new(); + if (!xattr_req) { + errno = ENOMEM; + goto out; + } - } - - glret = priv_glfs_loc_touchup (&loc); - if (glret < 0) { - ret = -1; - goto out; - } - - ret = syncop_lookup (subvol, &loc, &ciatt, NULL, xattr_req, NULL); - if (ret && reval) { - /* - * A stale mapping might exist for a dentry/inode that has been - * removed from another client. - */ - if (-ret == ENOENT) { - inode_unlink(loc.inode, loc.parent, - loc.name); - if (!inode_has_dentry (loc.inode)) - inode_forget (loc.inode, 0); - } + ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true); + if (ret) { + errno = ENOMEM; + goto out; + } + } + + glret = priv_glfs_loc_touchup(&loc); + if (glret < 0) { + ret = -1; + goto out; + } + + ret = syncop_lookup(subvol, &loc, &ciatt, NULL, xattr_req, NULL); + if (ret && reval) { + /* + * A stale mapping might exist for a dentry/inode that has been + * removed from another client. + */ + if (-ret == ENOENT) { + inode_unlink(loc.inode, loc.parent, loc.name); + if (!inode_has_dentry(loc.inode)) + inode_forget(loc.inode, 0); + } - inode_unref (loc.inode); - gf_uuid_clear (loc.gfid); - loc.inode = inode_new (parent->table); - if (!loc.inode) { - errno = ENOMEM; - goto out; - } - - xattr_req = dict_new (); - if (!xattr_req) { - errno = ENOMEM; - goto out; - } - - gf_uuid_generate (gfid); - - ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true); - if (ret) { - errno = ENOMEM; - goto out; - } - - ret = syncop_lookup (subvol, &loc, &ciatt, NULL, - xattr_req, NULL); - } - DECODE_SYNCOP_ERR (ret); - if (ret) - goto out; - - inode = inode_link (loc.inode, loc.parent, component, &ciatt); + inode_unref(loc.inode); + gf_uuid_clear(loc.gfid); + loc.inode = inode_new(parent->table); + if (!loc.inode) { + errno = ENOMEM; + goto out; + } - if (!inode) { - gf_msg (subvol->name, GF_LOG_WARNING, errno, - API_MSG_INODE_LINK_FAILED, - "inode linking of %s failed", - uuid_utoa ((unsigned char *)&ciatt.ia_gfid)); - goto out; - } else if (inode == loc.inode) - inode_ctx_set (inode, THIS, &ctx_value); -found: - if (inode) { - ciatt.ia_type = inode->ia_type; - inode_lookup (inode); + xattr_req = dict_new(); + if (!xattr_req) { + errno = ENOMEM; + goto out; + } + + gf_uuid_generate(gfid); + + ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true); + if (ret) { + errno = ENOMEM; + goto out; } - if (iatt) - *iatt = ciatt; + + ret = syncop_lookup(subvol, &loc, &ciatt, NULL, xattr_req, NULL); + } + DECODE_SYNCOP_ERR(ret); + if (ret) + goto out; + + inode = inode_link(loc.inode, loc.parent, component, &ciatt); + + if (!inode) { + gf_msg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED, + "inode linking of %s failed", + uuid_utoa((unsigned char *)&ciatt.ia_gfid)); + goto out; + } else if (inode == loc.inode) + inode_ctx_set(inode, THIS, &ctx_value); +found: + if (inode) { + ciatt.ia_type = inode->ia_type; + inode_lookup(inode); + } + if (iatt) + *iatt = ciatt; out: - if (xattr_req) - dict_unref (xattr_req); - loc_wipe (&loc); + if (xattr_req) + dict_unref(xattr_req); + loc_wipe(&loc); - return inode; + return inode; } - int -priv_glfs_resolve_at (struct glfs *fs, xlator_t *subvol, inode_t *at, - const char *origpath, loc_t *loc, struct iatt *iatt, - int follow, int reval) +priv_glfs_resolve_at(struct glfs *fs, xlator_t *subvol, inode_t *at, + const char *origpath, loc_t *loc, struct iatt *iatt, + int follow, int reval) { - inode_t *inode = NULL; - inode_t *parent = NULL; - char *saveptr = NULL; - char *path = NULL; - char *component = NULL; - char *next_component = NULL; - int ret = -1; - struct iatt ciatt = {0, }; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - - if (origpath[0] == '\0') { - errno = EINVAL; - goto invalid_fs; + inode_t *inode = NULL; + inode_t *parent = NULL; + char *saveptr = NULL; + char *path = NULL; + char *component = NULL; + char *next_component = NULL; + int ret = -1; + struct iatt ciatt = { + 0, + }; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + if (origpath[0] == '\0') { + errno = EINVAL; + goto invalid_fs; + } + + parent = NULL; + if (at && origpath[0] != '/') { + /* A relative resolution of a path which starts with '/' + is equal to an absolute path resolution. + */ + inode = inode_ref(at); + } else { + inode = inode_ref(subvol->itable->root); + + if (strcmp(origpath, "/") == 0) + glfs_resolve_root(fs, subvol, inode, &ciatt); + } + + path = gf_strdup(origpath); + if (!path) + goto invalid_fs; + + for (component = strtok_r(path, "/", &saveptr); component; + component = next_component) { + next_component = strtok_r(NULL, "/", &saveptr); + + if (parent) + inode_unref(parent); + parent = inode; + inode = glfs_resolve_component(fs, subvol, parent, component, &ciatt, + /* force hard lookup on the last + component, as the caller + wants proper iatt filled + */ + (reval || (!next_component && iatt))); + if (!inode) { + ret = -1; + break; } - parent = NULL; - if (at && origpath[0] != '/') { - /* A relative resolution of a path which starts with '/' - is equal to an absolute path resolution. - */ - inode = inode_ref (at); - } else { - inode = inode_ref (subvol->itable->root); - - if (strcmp (origpath, "/") == 0) - glfs_resolve_root (fs, subvol, inode, &ciatt); - } - - path = gf_strdup (origpath); - if (!path) - goto invalid_fs; - - for (component = strtok_r (path, "/", &saveptr); - component; component = next_component) { - - next_component = strtok_r (NULL, "/", &saveptr); - - if (parent) - inode_unref (parent); - parent = inode; - inode = glfs_resolve_component (fs, subvol, parent, - component, &ciatt, - /* force hard lookup on the last - component, as the caller - wants proper iatt filled - */ - (reval || (!next_component && - iatt))); - if (!inode) { - ret = -1; - break; + if (IA_ISLNK(ciatt.ia_type) && (next_component || follow)) { + /* If the component is not the last piece, + then following it is necessary even if + not requested by the caller + */ + char *lpath = NULL; + loc_t sym_loc = { + 0, + }; + + if (follow > GLFS_SYMLINK_MAX_FOLLOW) { + errno = ELOOP; + ret = -1; + if (inode) { + inode_unref(inode); + inode = NULL; } + break; + } + + ret = glfs_resolve_symlink(fs, subvol, inode, &lpath); + inode_unref(inode); + inode = NULL; + if (ret < 0) + break; + + ret = priv_glfs_resolve_at(fs, subvol, parent, lpath, &sym_loc, + /* followed iatt becomes the + component iatt + */ + &ciatt, + /* always recurisvely follow while + following symlink + */ + follow + 1, reval); + if (ret == 0) + inode = inode_ref(sym_loc.inode); + loc_wipe(&sym_loc); + GF_FREE(lpath); + } - if (IA_ISLNK (ciatt.ia_type) && (next_component || follow)) { - /* If the component is not the last piece, - then following it is necessary even if - not requested by the caller - */ - char *lpath = NULL; - loc_t sym_loc = {0,}; - - if (follow > GLFS_SYMLINK_MAX_FOLLOW) { - errno = ELOOP; - ret = -1; - if (inode) { - inode_unref (inode); - inode = NULL; - } - break; - } - - ret = glfs_resolve_symlink (fs, subvol, inode, &lpath); - inode_unref (inode); - inode = NULL; - if (ret < 0) - break; - - ret = priv_glfs_resolve_at (fs, subvol, parent, lpath, - &sym_loc, - /* followed iatt becomes the - component iatt - */ - &ciatt, - /* always recurisvely follow while - following symlink - */ - follow + 1, reval); - if (ret == 0) - inode = inode_ref (sym_loc.inode); - loc_wipe (&sym_loc); - GF_FREE (lpath); - } - - if (!next_component) - break; - - if (!IA_ISDIR (ciatt.ia_type)) { - /* next_component exists and this component is - not a directory - */ - inode_unref (inode); - inode = NULL; - ret = -1; - errno = ENOTDIR; - break; - } - } - - if (parent && next_component) - /* resolution failed mid-way */ - goto out; - - /* At this point, all components up to the last parent directory - have been resolved successfully (@parent). Resolution of basename - might have failed (@inode) if at all. - */ - - loc->parent = parent; - if (parent) { - gf_uuid_copy (loc->pargfid, parent->gfid); - loc->name = component; - } - - loc->inode = inode; - if (inode) { - gf_uuid_copy (loc->gfid, inode->gfid); - if (iatt) - *iatt = ciatt; - ret = 0; - } - - if (priv_glfs_loc_touchup (loc) < 0) { - ret = -1; + if (!next_component) + break; + + if (!IA_ISDIR(ciatt.ia_type)) { + /* next_component exists and this component is + not a directory + */ + inode_unref(inode); + inode = NULL; + ret = -1; + errno = ENOTDIR; + break; } + } + + if (parent && next_component) + /* resolution failed mid-way */ + goto out; + + /* At this point, all components up to the last parent directory + have been resolved successfully (@parent). Resolution of basename + might have failed (@inode) if at all. + */ + + loc->parent = parent; + if (parent) { + gf_uuid_copy(loc->pargfid, parent->gfid); + loc->name = component; + } + + loc->inode = inode; + if (inode) { + gf_uuid_copy(loc->gfid, inode->gfid); + if (iatt) + *iatt = ciatt; + ret = 0; + } + + if (priv_glfs_loc_touchup(loc) < 0) { + ret = -1; + } out: - GF_FREE (path); - __GLFS_EXIT_FS; + GF_FREE(path); + __GLFS_EXIT_FS; - /* do NOT loc_wipe here as only last component might be missing */ + /* do NOT loc_wipe here as only last component might be missing */ invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_resolve_at, 3.4.0); - int -glfs_resolve_path (struct glfs *fs, xlator_t *subvol, const char *origpath, - loc_t *loc, struct iatt *iatt, int follow, int reval) +glfs_resolve_path(struct glfs *fs, xlator_t *subvol, const char *origpath, + loc_t *loc, struct iatt *iatt, int follow, int reval) { - int ret = -1; - inode_t *cwd = NULL; - - if (origpath[0] == '/') - return priv_glfs_resolve_at (fs, subvol, NULL, origpath, loc, - iatt, follow, reval); - - cwd = glfs_cwd_get (fs); - if (NULL == cwd) { - gf_msg (subvol->name, GF_LOG_WARNING, EIO, - API_MSG_GET_CWD_FAILED, "Failed to get cwd"); - errno = EIO; - goto out; - } + int ret = -1; + inode_t *cwd = NULL; - ret = priv_glfs_resolve_at (fs, subvol, cwd, origpath, loc, iatt, + if (origpath[0] == '/') + return priv_glfs_resolve_at(fs, subvol, NULL, origpath, loc, iatt, follow, reval); - if (cwd) - inode_unref (cwd); + + cwd = glfs_cwd_get(fs); + if (NULL == cwd) { + gf_msg(subvol->name, GF_LOG_WARNING, EIO, API_MSG_GET_CWD_FAILED, + "Failed to get cwd"); + errno = EIO; + goto out; + } + + ret = priv_glfs_resolve_at(fs, subvol, cwd, origpath, loc, iatt, follow, + reval); + if (cwd) + inode_unref(cwd); out: - return ret; + return ret; } - int -priv_glfs_resolve (struct glfs *fs, xlator_t *subvol, const char *origpath, - loc_t *loc, struct iatt *iatt, int reval) +priv_glfs_resolve(struct glfs *fs, xlator_t *subvol, const char *origpath, + loc_t *loc, struct iatt *iatt, int reval) { - int ret = -1; + int ret = -1; - ret = glfs_resolve_path (fs, subvol, origpath, loc, iatt, 1, reval); + ret = glfs_resolve_path(fs, subvol, origpath, loc, iatt, 1, reval); - return ret; + return ret; } GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_resolve, 3.7.0); int -glfs_lresolve (struct glfs *fs, xlator_t *subvol, const char *origpath, - loc_t *loc, struct iatt *iatt, int reval) +glfs_lresolve(struct glfs *fs, xlator_t *subvol, const char *origpath, + loc_t *loc, struct iatt *iatt, int reval) { - int ret = -1; + int ret = -1; - ret = glfs_resolve_path (fs, subvol, origpath, loc, iatt, 0, reval); + ret = glfs_resolve_path(fs, subvol, origpath, loc, iatt, 0, reval); - return ret; + return ret; } - int -glfs_migrate_fd_locks_safe (struct glfs *fs, xlator_t *oldsubvol, fd_t *oldfd, - xlator_t *newsubvol, fd_t *newfd) +glfs_migrate_fd_locks_safe(struct glfs *fs, xlator_t *oldsubvol, fd_t *oldfd, + xlator_t *newsubvol, fd_t *newfd) { - dict_t *lockinfo = NULL; - int ret = 0; - char uuid1[64]; - - if (!oldfd->lk_ctx || fd_lk_ctx_empty (oldfd->lk_ctx)) - return 0; - - newfd->lk_ctx = fd_lk_ctx_ref (oldfd->lk_ctx); - - ret = syncop_fgetxattr (oldsubvol, oldfd, &lockinfo, - GF_XATTR_LOCKINFO_KEY, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - if (ret < 0) { - gf_msg (fs->volname, GF_LOG_WARNING, errno, - API_MSG_FGETXATTR_FAILED, - "fgetxattr (%s) failed (%s) on graph %s (%d)", - uuid_utoa_r (oldfd->inode->gfid, uuid1), - strerror (errno), - graphid_str (oldsubvol), oldsubvol->graph->id); - goto out; - } - - if (!dict_get (lockinfo, GF_XATTR_LOCKINFO_KEY)) { - gf_msg (fs->volname, GF_LOG_WARNING, 0, - API_MSG_LOCKINFO_KEY_MISSING, - "missing lockinfo key (%s) on graph %s (%d)", - uuid_utoa_r (oldfd->inode->gfid, uuid1), - graphid_str (oldsubvol), oldsubvol->graph->id); - goto out; - } - - ret = syncop_fsetxattr (newsubvol, newfd, lockinfo, 0, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - if (ret < 0) { - gf_msg (fs->volname, GF_LOG_WARNING, 0, - API_MSG_FSETXATTR_FAILED, - "fsetxattr (%s) failed (%s) on graph %s (%d)", - uuid_utoa_r (newfd->inode->gfid, uuid1), - strerror (errno), - graphid_str (newsubvol), newsubvol->graph->id); - goto out; - } + dict_t *lockinfo = NULL; + int ret = 0; + char uuid1[64]; + + if (!oldfd->lk_ctx || fd_lk_ctx_empty(oldfd->lk_ctx)) + return 0; + + newfd->lk_ctx = fd_lk_ctx_ref(oldfd->lk_ctx); + + ret = syncop_fgetxattr(oldsubvol, oldfd, &lockinfo, GF_XATTR_LOCKINFO_KEY, + NULL, NULL); + DECODE_SYNCOP_ERR(ret); + if (ret < 0) { + gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FGETXATTR_FAILED, + "fgetxattr (%s) failed (%s) on graph %s (%d)", + uuid_utoa_r(oldfd->inode->gfid, uuid1), strerror(errno), + graphid_str(oldsubvol), oldsubvol->graph->id); + goto out; + } + + if (!dict_get(lockinfo, GF_XATTR_LOCKINFO_KEY)) { + gf_msg(fs->volname, GF_LOG_WARNING, 0, API_MSG_LOCKINFO_KEY_MISSING, + "missing lockinfo key (%s) on graph %s (%d)", + uuid_utoa_r(oldfd->inode->gfid, uuid1), graphid_str(oldsubvol), + oldsubvol->graph->id); + goto out; + } + + ret = syncop_fsetxattr(newsubvol, newfd, lockinfo, 0, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + if (ret < 0) { + gf_msg(fs->volname, GF_LOG_WARNING, 0, API_MSG_FSETXATTR_FAILED, + "fsetxattr (%s) failed (%s) on graph %s (%d)", + uuid_utoa_r(newfd->inode->gfid, uuid1), strerror(errno), + graphid_str(newsubvol), newsubvol->graph->id); + goto out; + } out: - if (lockinfo) - dict_unref (lockinfo); - return ret; + if (lockinfo) + dict_unref(lockinfo); + return ret; } - fd_t * -glfs_migrate_fd_safe (struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd) +glfs_migrate_fd_safe(struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd) { - fd_t *newfd = NULL; - inode_t *oldinode = NULL; - inode_t *newinode = NULL; - xlator_t *oldsubvol = NULL; - int ret = -1; - loc_t loc = {0, }; - char uuid1[64]; - - - oldinode = oldfd->inode; - oldsubvol = oldinode->table->xl; - - if (oldsubvol == newsubvol) - return fd_ref (oldfd); - - if (!oldsubvol->switched) { - ret = syncop_fsync (oldsubvol, oldfd, 0, NULL, NULL, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - if (ret) { - gf_msg (fs->volname, GF_LOG_WARNING, errno, - API_MSG_FSYNC_FAILED, "fsync() failed " - "(%s) on %s graph %s (%d)", strerror (errno), - uuid_utoa_r (oldfd->inode->gfid, uuid1), - graphid_str (oldsubvol), oldsubvol->graph->id); - } - } - - newinode = glfs_refresh_inode_safe (newsubvol, oldinode, _gf_false); - if (!newinode) { - gf_msg (fs->volname, GF_LOG_WARNING, errno, - API_MSG_INODE_REFRESH_FAILED, - "inode (%s) refresh failed (%s) on graph %s (%d)", - uuid_utoa_r (oldinode->gfid, uuid1), - strerror (errno), - graphid_str (newsubvol), newsubvol->graph->id); - goto out; - } - - newfd = fd_create (newinode, getpid()); - if (!newfd) { - gf_msg (fs->volname, GF_LOG_WARNING, errno, - API_MSG_FDCREATE_FAILED, - "fd_create (%s) failed (%s) on graph %s (%d)", - uuid_utoa_r (newinode->gfid, uuid1), - strerror (errno), - graphid_str (newsubvol), newsubvol->graph->id); - goto out; - } - - loc.inode = inode_ref (newinode); - - ret = inode_path (oldfd->inode, NULL, (char **)&loc.path); - if (ret < 0) { - gf_msg (fs->volname, GF_LOG_INFO, 0, API_MSG_INODE_PATH_FAILED, - "inode_path failed"); - goto out; + fd_t *newfd = NULL; + inode_t *oldinode = NULL; + inode_t *newinode = NULL; + xlator_t *oldsubvol = NULL; + int ret = -1; + loc_t loc = { + 0, + }; + char uuid1[64]; + + oldinode = oldfd->inode; + oldsubvol = oldinode->table->xl; + + if (oldsubvol == newsubvol) + return fd_ref(oldfd); + + if (!oldsubvol->switched) { + ret = syncop_fsync(oldsubvol, oldfd, 0, NULL, NULL, NULL, NULL); + DECODE_SYNCOP_ERR(ret); + if (ret) { + gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FSYNC_FAILED, + "fsync() failed " + "(%s) on %s graph %s (%d)", + strerror(errno), uuid_utoa_r(oldfd->inode->gfid, uuid1), + graphid_str(oldsubvol), oldsubvol->graph->id); } - - gf_uuid_copy (loc.gfid, oldinode->gfid); - - - if (IA_ISDIR (oldinode->ia_type)) - ret = syncop_opendir (newsubvol, &loc, newfd, NULL, NULL); - else - ret = syncop_open (newsubvol, &loc, - oldfd->flags & ~(O_TRUNC|O_EXCL|O_CREAT), - newfd, NULL, NULL); - DECODE_SYNCOP_ERR (ret); - loc_wipe (&loc); - - if (ret) { - gf_msg (fs->volname, GF_LOG_WARNING, errno, - API_MSG_SYNCOP_OPEN_FAILED, - "syncop_open%s (%s) failed (%s) on graph %s (%d)", - IA_ISDIR (oldinode->ia_type) ? "dir" : "", - uuid_utoa_r (newinode->gfid, uuid1), - strerror (errno), - graphid_str (newsubvol), newsubvol->graph->id); - goto out; - } - - ret = glfs_migrate_fd_locks_safe (fs, oldsubvol, oldfd, newsubvol, - newfd); - - if (ret) { - gf_msg (fs->volname, GF_LOG_WARNING, errno, - API_MSG_LOCK_MIGRATE_FAILED, - "lock migration (%s) failed (%s) on graph %s (%d)", - uuid_utoa_r (newinode->gfid, uuid1), - strerror (errno), - graphid_str (newsubvol), newsubvol->graph->id); - goto out; - } - - newfd->flags = oldfd->flags; - fd_bind (newfd); + } + + newinode = glfs_refresh_inode_safe(newsubvol, oldinode, _gf_false); + if (!newinode) { + gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_INODE_REFRESH_FAILED, + "inode (%s) refresh failed (%s) on graph %s (%d)", + uuid_utoa_r(oldinode->gfid, uuid1), strerror(errno), + graphid_str(newsubvol), newsubvol->graph->id); + goto out; + } + + newfd = fd_create(newinode, getpid()); + if (!newfd) { + gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FDCREATE_FAILED, + "fd_create (%s) failed (%s) on graph %s (%d)", + uuid_utoa_r(newinode->gfid, uuid1), strerror(errno), + graphid_str(newsubvol), newsubvol->graph->id); + goto out; + } + + loc.inode = inode_ref(newinode); + + ret = inode_path(oldfd->inode, NULL, (char **)&loc.path); + if (ret < 0) { + gf_msg(fs->volname, GF_LOG_INFO, 0, API_MSG_INODE_PATH_FAILED, + "inode_path failed"); + goto out; + } + + gf_uuid_copy(loc.gfid, oldinode->gfid); + + if (IA_ISDIR(oldinode->ia_type)) + ret = syncop_opendir(newsubvol, &loc, newfd, NULL, NULL); + else + ret = syncop_open(newsubvol, &loc, + oldfd->flags & ~(O_TRUNC | O_EXCL | O_CREAT), newfd, + NULL, NULL); + DECODE_SYNCOP_ERR(ret); + loc_wipe(&loc); + + if (ret) { + gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_SYNCOP_OPEN_FAILED, + "syncop_open%s (%s) failed (%s) on graph %s (%d)", + IA_ISDIR(oldinode->ia_type) ? "dir" : "", + uuid_utoa_r(newinode->gfid, uuid1), strerror(errno), + graphid_str(newsubvol), newsubvol->graph->id); + goto out; + } + + ret = glfs_migrate_fd_locks_safe(fs, oldsubvol, oldfd, newsubvol, newfd); + + if (ret) { + gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_LOCK_MIGRATE_FAILED, + "lock migration (%s) failed (%s) on graph %s (%d)", + uuid_utoa_r(newinode->gfid, uuid1), strerror(errno), + graphid_str(newsubvol), newsubvol->graph->id); + goto out; + } + + newfd->flags = oldfd->flags; + fd_bind(newfd); out: - if (newinode) - inode_unref (newinode); + if (newinode) + inode_unref(newinode); - if (ret) { - fd_unref (newfd); - newfd = NULL; - } + if (ret) { + fd_unref(newfd); + newfd = NULL; + } - return newfd; + return newfd; } - fd_t * -__glfs_migrate_fd (struct glfs *fs, xlator_t *newsubvol, struct glfs_fd *glfd) +__glfs_migrate_fd(struct glfs *fs, xlator_t *newsubvol, struct glfs_fd *glfd) { - fd_t *oldfd = NULL; - fd_t *newfd = NULL; + fd_t *oldfd = NULL; + fd_t *newfd = NULL; - oldfd = glfd->fd; + oldfd = glfd->fd; - fs->migration_in_progress = 1; - pthread_mutex_unlock (&fs->mutex); - { - newfd = glfs_migrate_fd_safe (fs, newsubvol, oldfd); - } - pthread_mutex_lock (&fs->mutex); - fs->migration_in_progress = 0; - pthread_cond_broadcast (&fs->cond); + fs->migration_in_progress = 1; + pthread_mutex_unlock(&fs->mutex); + { + newfd = glfs_migrate_fd_safe(fs, newsubvol, oldfd); + } + pthread_mutex_lock(&fs->mutex); + fs->migration_in_progress = 0; + pthread_cond_broadcast(&fs->cond); - return newfd; + return newfd; } - fd_t * -__glfs_resolve_fd (struct glfs *fs, xlator_t *subvol, struct glfs_fd *glfd) +__glfs_resolve_fd(struct glfs *fs, xlator_t *subvol, struct glfs_fd *glfd) { - fd_t *fd = NULL; + fd_t *fd = NULL; - if (glfd->fd->inode->table->xl == subvol) - return fd_ref (glfd->fd); + if (glfd->fd->inode->table->xl == subvol) + return fd_ref(glfd->fd); - fd = __glfs_migrate_fd (fs, subvol, glfd); - if (!fd) - return NULL; + fd = __glfs_migrate_fd(fs, subvol, glfd); + if (!fd) + return NULL; - if (subvol == fs->active_subvol) { - fd_unref (glfd->fd); - glfd->fd = fd_ref (fd); - } + if (subvol == fs->active_subvol) { + fd_unref(glfd->fd); + glfd->fd = fd_ref(fd); + } - return fd; + return fd; } - fd_t * -glfs_resolve_fd (struct glfs *fs, xlator_t *subvol, struct glfs_fd *glfd) +glfs_resolve_fd(struct glfs *fs, xlator_t *subvol, struct glfs_fd *glfd) { - fd_t *fd = NULL; + fd_t *fd = NULL; - glfs_lock (fs, _gf_true); - { - fd = __glfs_resolve_fd (fs, subvol, glfd); - } - glfs_unlock (fs); + glfs_lock(fs, _gf_true); + { + fd = __glfs_resolve_fd(fs, subvol, glfd); + } + glfs_unlock(fs); - return fd; + return fd; } - void -__glfs_migrate_openfds (struct glfs *fs, xlator_t *subvol) +__glfs_migrate_openfds(struct glfs *fs, xlator_t *subvol) { - struct glfs_fd *glfd = NULL; - fd_t *fd = NULL; - - list_for_each_entry (glfd, &fs->openfds, openfds) { - if (gf_uuid_is_null (glfd->fd->inode->gfid)) { - gf_msg (fs->volname, GF_LOG_INFO, 0, - API_MSG_OPENFD_SKIPPED, - "skipping openfd %p/%p in graph %s (%d)", - glfd, glfd->fd, graphid_str(subvol), - subvol->graph->id); - /* create in progress, defer */ - continue; - } - - fd = __glfs_migrate_fd (fs, subvol, glfd); - if (fd) { - fd_unref (glfd->fd); - glfd->fd = fd; - } - } -} + struct glfs_fd *glfd = NULL; + fd_t *fd = NULL; + + list_for_each_entry(glfd, &fs->openfds, openfds) + { + if (gf_uuid_is_null(glfd->fd->inode->gfid)) { + gf_msg(fs->volname, GF_LOG_INFO, 0, API_MSG_OPENFD_SKIPPED, + "skipping openfd %p/%p in graph %s (%d)", glfd, glfd->fd, + graphid_str(subvol), subvol->graph->id); + /* create in progress, defer */ + continue; + } + fd = __glfs_migrate_fd(fs, subvol, glfd); + if (fd) { + fd_unref(glfd->fd); + glfd->fd = fd; + } + } +} /* Note that though it appears that this function executes under fs->mutex, * it is not fully executed under fs->mutex. i.e. there are functions like @@ -921,290 +898,284 @@ __glfs_migrate_openfds (struct glfs *fs, xlator_t *subvol) * function need not have the same value by the end of the function. */ xlator_t * -__glfs_active_subvol (struct glfs *fs) +__glfs_active_subvol(struct glfs *fs) { - xlator_t *new_subvol = NULL; - int ret = -1; - inode_t *new_cwd = NULL; - - if (!fs->next_subvol) - return fs->active_subvol; - - new_subvol = fs->mip_subvol = fs->next_subvol; - fs->next_subvol = NULL; - - ret = __glfs_first_lookup (fs, new_subvol); - if (ret) { - gf_msg (fs->volname, GF_LOG_INFO, errno, - API_MSG_FIRST_LOOKUP_GRAPH_FAILED, - "first lookup on graph %s (%d) failed (%s)", - graphid_str (new_subvol), new_subvol->graph->id, - strerror (errno)); - return NULL; - } - - if (fs->cwd) { - new_cwd = __glfs_refresh_inode (fs, new_subvol, fs->cwd, - _gf_false); - - if (!new_cwd) { - char buf1[64]; - gf_msg (fs->volname, GF_LOG_INFO, errno, - API_MSG_CWD_GRAPH_REF_FAILED, - "cwd refresh of %s graph %s (%d) failed (%s)", - uuid_utoa_r (fs->cwd->gfid, buf1), - graphid_str (new_subvol), - new_subvol->graph->id, strerror (errno)); - return NULL; - } - } - - __glfs_migrate_openfds (fs, new_subvol); - /* TODO: Migrate the fds and inodes which have leases to the new graph (issue #350)*/ - - /* switching @active_subvol and @cwd - should be atomic - */ - fs->old_subvol = fs->active_subvol; - fs->active_subvol = fs->mip_subvol; - fs->mip_subvol = NULL; - - if (new_cwd) { - __glfs_cwd_set (fs, new_cwd); - inode_unref (new_cwd); - } - - gf_msg (fs->volname, GF_LOG_INFO, 0, API_MSG_SWITCHED_GRAPH, - "switched to graph %s (%d)", - graphid_str (new_subvol), new_subvol->graph->id); - - return new_subvol; -} + xlator_t *new_subvol = NULL; + int ret = -1; + inode_t *new_cwd = NULL; + + if (!fs->next_subvol) + return fs->active_subvol; + + new_subvol = fs->mip_subvol = fs->next_subvol; + fs->next_subvol = NULL; + + ret = __glfs_first_lookup(fs, new_subvol); + if (ret) { + gf_msg(fs->volname, GF_LOG_INFO, errno, + API_MSG_FIRST_LOOKUP_GRAPH_FAILED, + "first lookup on graph %s (%d) failed (%s)", + graphid_str(new_subvol), new_subvol->graph->id, strerror(errno)); + return NULL; + } + + if (fs->cwd) { + new_cwd = __glfs_refresh_inode(fs, new_subvol, fs->cwd, _gf_false); + + if (!new_cwd) { + char buf1[64]; + gf_msg(fs->volname, GF_LOG_INFO, errno, + API_MSG_CWD_GRAPH_REF_FAILED, + "cwd refresh of %s graph %s (%d) failed (%s)", + uuid_utoa_r(fs->cwd->gfid, buf1), graphid_str(new_subvol), + new_subvol->graph->id, strerror(errno)); + return NULL; + } + } + __glfs_migrate_openfds(fs, new_subvol); + /* TODO: Migrate the fds and inodes which have leases to the new graph + * (issue #350)*/ -void -priv_glfs_subvol_done (struct glfs *fs, xlator_t *subvol) -{ - int ref = 0; - xlator_t *active_subvol = NULL; + /* switching @active_subvol and @cwd + should be atomic + */ + fs->old_subvol = fs->active_subvol; + fs->active_subvol = fs->mip_subvol; + fs->mip_subvol = NULL; - if (!subvol) - return; + if (new_cwd) { + __glfs_cwd_set(fs, new_cwd); + inode_unref(new_cwd); + } - /* For decrementing subvol->wind ref count we need not check/wait for - * migration-in-progress flag. - * Also glfs_subvol_done is called in call-back path therefore waiting - * for migration-in-progress flag can lead to dead-lock. - */ - glfs_lock (fs, _gf_false); - { - ref = (--subvol->winds); - active_subvol = fs->active_subvol; - } - glfs_unlock (fs); - - if (ref == 0) { - assert (subvol != active_subvol); - xlator_notify (subvol, GF_EVENT_PARENT_DOWN, subvol, NULL); - } + gf_msg(fs->volname, GF_LOG_INFO, 0, API_MSG_SWITCHED_GRAPH, + "switched to graph %s (%d)", graphid_str(new_subvol), + new_subvol->graph->id); + + return new_subvol; } -GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_subvol_done, 3.4.0); +void +priv_glfs_subvol_done(struct glfs *fs, xlator_t *subvol) +{ + int ref = 0; + xlator_t *active_subvol = NULL; + + if (!subvol) + return; + + /* For decrementing subvol->wind ref count we need not check/wait for + * migration-in-progress flag. + * Also glfs_subvol_done is called in call-back path therefore waiting + * for migration-in-progress flag can lead to dead-lock. + */ + glfs_lock(fs, _gf_false); + { + ref = (--subvol->winds); + active_subvol = fs->active_subvol; + } + glfs_unlock(fs); + + if (ref == 0) { + assert(subvol != active_subvol); + xlator_notify(subvol, GF_EVENT_PARENT_DOWN, subvol, NULL); + } +} +GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_subvol_done, 3.4.0); xlator_t * -priv_glfs_active_subvol (struct glfs *fs) +priv_glfs_active_subvol(struct glfs *fs) { - xlator_t *subvol = NULL; - xlator_t *old_subvol = NULL; + xlator_t *subvol = NULL; + xlator_t *old_subvol = NULL; - glfs_lock (fs, _gf_true); - { - subvol = __glfs_active_subvol (fs); + glfs_lock(fs, _gf_true); + { + subvol = __glfs_active_subvol(fs); - if (subvol) - subvol->winds++; + if (subvol) + subvol->winds++; - if (fs->old_subvol) { - old_subvol = fs->old_subvol; - fs->old_subvol = NULL; - old_subvol->switched = 1; - } - } - glfs_unlock (fs); + if (fs->old_subvol) { + old_subvol = fs->old_subvol; + fs->old_subvol = NULL; + old_subvol->switched = 1; + } + } + glfs_unlock(fs); - if (old_subvol) - priv_glfs_subvol_done (fs, old_subvol); + if (old_subvol) + priv_glfs_subvol_done(fs, old_subvol); - return subvol; + return subvol; } GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_active_subvol, 3.4.0); int -__glfs_cwd_set (struct glfs *fs, inode_t *inode) +__glfs_cwd_set(struct glfs *fs, inode_t *inode) { - if (inode->table->xl != fs->active_subvol) { - inode = __glfs_refresh_inode (fs, fs->active_subvol, inode, - _gf_false); - if (!inode) - return -1; - } else { - inode_ref (inode); - } + if (inode->table->xl != fs->active_subvol) { + inode = __glfs_refresh_inode(fs, fs->active_subvol, inode, _gf_false); + if (!inode) + return -1; + } else { + inode_ref(inode); + } - if (fs->cwd) - inode_unref (fs->cwd); + if (fs->cwd) + inode_unref(fs->cwd); - fs->cwd = inode; + fs->cwd = inode; - return 0; + return 0; } - int -glfs_cwd_set (struct glfs *fs, inode_t *inode) +glfs_cwd_set(struct glfs *fs, inode_t *inode) { - int ret = 0; + int ret = 0; - glfs_lock (fs, _gf_true); - { - ret = __glfs_cwd_set (fs, inode); - } - glfs_unlock (fs); + glfs_lock(fs, _gf_true); + { + ret = __glfs_cwd_set(fs, inode); + } + glfs_unlock(fs); - return ret; + return ret; } - inode_t * -__glfs_cwd_get (struct glfs *fs) +__glfs_cwd_get(struct glfs *fs) { - inode_t *cwd = NULL; + inode_t *cwd = NULL; - if (!fs->cwd) - return NULL; + if (!fs->cwd) + return NULL; - if (fs->cwd->table->xl == fs->active_subvol) { - cwd = inode_ref (fs->cwd); - return cwd; - } + if (fs->cwd->table->xl == fs->active_subvol) { + cwd = inode_ref(fs->cwd); + return cwd; + } - cwd = __glfs_refresh_inode (fs, fs->active_subvol, fs->cwd, _gf_false); + cwd = __glfs_refresh_inode(fs, fs->active_subvol, fs->cwd, _gf_false); - return cwd; + return cwd; } inode_t * -glfs_cwd_get (struct glfs *fs) +glfs_cwd_get(struct glfs *fs) { - inode_t *cwd = NULL; + inode_t *cwd = NULL; - glfs_lock (fs, _gf_true); - { - cwd = __glfs_cwd_get (fs); - } - glfs_unlock (fs); + glfs_lock(fs, _gf_true); + { + cwd = __glfs_cwd_get(fs); + } + glfs_unlock(fs); - return cwd; + return cwd; } inode_t * -__glfs_resolve_inode (struct glfs *fs, xlator_t *subvol, - struct glfs_object *object) +__glfs_resolve_inode(struct glfs *fs, xlator_t *subvol, + struct glfs_object *object) { - inode_t *inode = NULL; - gf_boolean_t lookup_needed = _gf_false; + inode_t *inode = NULL; + gf_boolean_t lookup_needed = _gf_false; - lookup_needed = inode_needs_lookup (object->inode, THIS); + lookup_needed = inode_needs_lookup(object->inode, THIS); - if (!lookup_needed && object->inode->table->xl == subvol) - return inode_ref (object->inode); + if (!lookup_needed && object->inode->table->xl == subvol) + return inode_ref(object->inode); - inode = __glfs_refresh_inode (fs, fs->active_subvol, - object->inode, lookup_needed); - if (!inode) - return NULL; + inode = __glfs_refresh_inode(fs, fs->active_subvol, object->inode, + lookup_needed); + if (!inode) + return NULL; - if (subvol == fs->active_subvol) { - inode_unref (object->inode); - object->inode = inode_ref (inode); - } + if (subvol == fs->active_subvol) { + inode_unref(object->inode); + object->inode = inode_ref(inode); + } - return inode; + return inode; } inode_t * -glfs_resolve_inode (struct glfs *fs, xlator_t *subvol, - struct glfs_object *object) +glfs_resolve_inode(struct glfs *fs, xlator_t *subvol, + struct glfs_object *object) { - inode_t *inode = NULL; + inode_t *inode = NULL; - glfs_lock (fs, _gf_true); - { - inode = __glfs_resolve_inode(fs, subvol, object); - } - glfs_unlock (fs); + glfs_lock(fs, _gf_true); + { + inode = __glfs_resolve_inode(fs, subvol, object); + } + glfs_unlock(fs); - return inode; + return inode; } int -glfs_create_object (loc_t *loc, struct glfs_object **retobject) +glfs_create_object(loc_t *loc, struct glfs_object **retobject) { - struct glfs_object *object = NULL; + struct glfs_object *object = NULL; - object = GF_CALLOC (1, sizeof(struct glfs_object), - glfs_mt_glfs_object_t); - if (object == NULL) { - errno = ENOMEM; - return -1; - } + object = GF_CALLOC(1, sizeof(struct glfs_object), glfs_mt_glfs_object_t); + if (object == NULL) { + errno = ENOMEM; + return -1; + } - object->inode = loc->inode; - gf_uuid_copy (object->gfid, object->inode->gfid); + object->inode = loc->inode; + gf_uuid_copy(object->gfid, object->inode->gfid); - /* we hold the reference */ - loc->inode = NULL; + /* we hold the reference */ + loc->inode = NULL; - *retobject = object; + *retobject = object; - return 0; + return 0; } struct glfs_object * -glfs_h_resolve_symlink (struct glfs *fs, struct glfs_object *object) +glfs_h_resolve_symlink(struct glfs *fs, struct glfs_object *object) { - - xlator_t *subvol = NULL; - loc_t sym_loc = {0,}; - struct iatt iatt = {0,}; - char *lpath = NULL; - int ret = 0; - struct glfs_object *target_object = NULL; - - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } - - ret = glfs_resolve_symlink (fs, subvol, object->inode, &lpath); - if (ret < 0) - goto out; - - ret = glfs_resolve_at (fs, subvol, NULL, lpath, - &sym_loc, &iatt, - /* always recurisvely follow while - following symlink - */ - 1, 0); - if (ret == 0) - ret = glfs_create_object (&sym_loc, &target_object); + xlator_t *subvol = NULL; + loc_t sym_loc = { + 0, + }; + struct iatt iatt = { + 0, + }; + char *lpath = NULL; + int ret = 0; + struct glfs_object *target_object = NULL; + + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } + + ret = glfs_resolve_symlink(fs, subvol, object->inode, &lpath); + if (ret < 0) + goto out; + + ret = glfs_resolve_at(fs, subvol, NULL, lpath, &sym_loc, &iatt, + /* always recurisvely follow while + following symlink + */ + 1, 0); + if (ret == 0) + ret = glfs_create_object(&sym_loc, &target_object); out: - loc_wipe (&sym_loc); - GF_FREE (lpath); - return target_object; + loc_wipe(&sym_loc); + GF_FREE(lpath); + return target_object; } diff --git a/api/src/glfs.c b/api/src/glfs.c index 8ae3af61edb..d21cb8b334f 100644 --- a/api/src/glfs.c +++ b/api/src/glfs.c @@ -8,7 +8,6 @@ cases as published by the Free Software Foundation. */ - /* TODO: - set proper pid/lk_owner to call frames (currently buried in syncop) @@ -51,444 +50,422 @@ #include "glfs.h" #include "glfs-internal.h" - static gf_boolean_t -vol_assigned (cmd_args_t *args) +vol_assigned(cmd_args_t *args) { - return args->volfile || args->volfile_server; + return args->volfile || args->volfile_server; } - static int -glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx) +glusterfs_ctx_defaults_init(glusterfs_ctx_t *ctx) { - call_pool_t *pool = NULL; - int ret = -1; - - if (!ctx) { - goto err; - } - - ret = xlator_mem_acct_init (THIS, glfs_mt_end + 1); - if (ret != 0) { - gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM, - API_MSG_MEM_ACCT_INIT_FAILED, - "Memory accounting init failed"); - return ret; - } - - /* reset ret to -1 so that we don't need to explicitly - * set it in all error paths before "goto err" - */ + call_pool_t *pool = NULL; + int ret = -1; - ret = -1; + if (!ctx) { + goto err; + } - ctx->process_uuid = generate_glusterfs_ctx_id (); - if (!ctx->process_uuid) { - goto err; - } - - ctx->page_size = 128 * GF_UNIT_KB; - - ctx->iobuf_pool = iobuf_pool_new (); - if (!ctx->iobuf_pool) { - goto err; - } - - ctx->event_pool = event_pool_new (DEFAULT_EVENT_POOL_SIZE, - STARTING_EVENT_THREADS); - if (!ctx->event_pool) { - goto err; - } - - ctx->env = syncenv_new (0, 0, 0); - if (!ctx->env) { - goto err; - } - - pool = GF_CALLOC (1, sizeof (call_pool_t), - glfs_mt_call_pool_t); - if (!pool) { - goto err; - } - - /* frame_mem_pool size 112 * 4k */ - pool->frame_mem_pool = mem_pool_new (call_frame_t, 4096); - if (!pool->frame_mem_pool) { - goto err; - } - /* stack_mem_pool size 256 * 1024 */ - pool->stack_mem_pool = mem_pool_new (call_stack_t, 1024); - if (!pool->stack_mem_pool) { - goto err; - } - - ctx->stub_mem_pool = mem_pool_new (call_stub_t, 1024); - if (!ctx->stub_mem_pool) { - goto err; - } - - ctx->dict_pool = mem_pool_new (dict_t, GF_MEMPOOL_COUNT_OF_DICT_T); - if (!ctx->dict_pool) - goto err; - - ctx->dict_pair_pool = mem_pool_new (data_pair_t, - GF_MEMPOOL_COUNT_OF_DATA_PAIR_T); - if (!ctx->dict_pair_pool) - goto err; - - ctx->dict_data_pool = mem_pool_new (data_t, GF_MEMPOOL_COUNT_OF_DATA_T); - if (!ctx->dict_data_pool) - goto err; - - ctx->logbuf_pool = mem_pool_new (log_buf_t, - GF_MEMPOOL_COUNT_OF_LRU_BUF_T); - if (!ctx->logbuf_pool) - goto err; - - INIT_LIST_HEAD (&pool->all_frames); - INIT_LIST_HEAD (&ctx->cmd_args.xlator_options); - INIT_LIST_HEAD (&ctx->cmd_args.volfile_servers); - - LOCK_INIT (&pool->lock); - ctx->pool = pool; - - ret = 0; + ret = xlator_mem_acct_init(THIS, glfs_mt_end + 1); + if (ret != 0) { + gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_MEM_ACCT_INIT_FAILED, + "Memory accounting init failed"); + return ret; + } + + /* reset ret to -1 so that we don't need to explicitly + * set it in all error paths before "goto err" + */ + + ret = -1; + + ctx->process_uuid = generate_glusterfs_ctx_id(); + if (!ctx->process_uuid) { + goto err; + } + + ctx->page_size = 128 * GF_UNIT_KB; + + ctx->iobuf_pool = iobuf_pool_new(); + if (!ctx->iobuf_pool) { + goto err; + } + + ctx->event_pool = event_pool_new(DEFAULT_EVENT_POOL_SIZE, + STARTING_EVENT_THREADS); + if (!ctx->event_pool) { + goto err; + } + + ctx->env = syncenv_new(0, 0, 0); + if (!ctx->env) { + goto err; + } + + pool = GF_CALLOC(1, sizeof(call_pool_t), glfs_mt_call_pool_t); + if (!pool) { + goto err; + } + + /* frame_mem_pool size 112 * 4k */ + pool->frame_mem_pool = mem_pool_new(call_frame_t, 4096); + if (!pool->frame_mem_pool) { + goto err; + } + /* stack_mem_pool size 256 * 1024 */ + pool->stack_mem_pool = mem_pool_new(call_stack_t, 1024); + if (!pool->stack_mem_pool) { + goto err; + } + + ctx->stub_mem_pool = mem_pool_new(call_stub_t, 1024); + if (!ctx->stub_mem_pool) { + goto err; + } + + ctx->dict_pool = mem_pool_new(dict_t, GF_MEMPOOL_COUNT_OF_DICT_T); + if (!ctx->dict_pool) + goto err; + + ctx->dict_pair_pool = mem_pool_new(data_pair_t, + GF_MEMPOOL_COUNT_OF_DATA_PAIR_T); + if (!ctx->dict_pair_pool) + goto err; + + ctx->dict_data_pool = mem_pool_new(data_t, GF_MEMPOOL_COUNT_OF_DATA_T); + if (!ctx->dict_data_pool) + goto err; + + ctx->logbuf_pool = mem_pool_new(log_buf_t, GF_MEMPOOL_COUNT_OF_LRU_BUF_T); + if (!ctx->logbuf_pool) + goto err; + + INIT_LIST_HEAD(&pool->all_frames); + INIT_LIST_HEAD(&ctx->cmd_args.xlator_options); + INIT_LIST_HEAD(&ctx->cmd_args.volfile_servers); + + LOCK_INIT(&pool->lock); + ctx->pool = pool; + + ret = 0; err: - if (ret && pool) { - if (pool->frame_mem_pool) - mem_pool_destroy (pool->frame_mem_pool); - if (pool->stack_mem_pool) - mem_pool_destroy (pool->stack_mem_pool); - GF_FREE (pool); - } - - if (ret && ctx) { - if (ctx->stub_mem_pool) - mem_pool_destroy (ctx->stub_mem_pool); - if (ctx->dict_pool) - mem_pool_destroy (ctx->dict_pool); - if (ctx->dict_data_pool) - mem_pool_destroy (ctx->dict_data_pool); - if (ctx->dict_pair_pool) - mem_pool_destroy (ctx->dict_pair_pool); - if (ctx->logbuf_pool) - mem_pool_destroy (ctx->logbuf_pool); - } - - return ret; -} + if (ret && pool) { + if (pool->frame_mem_pool) + mem_pool_destroy(pool->frame_mem_pool); + if (pool->stack_mem_pool) + mem_pool_destroy(pool->stack_mem_pool); + GF_FREE(pool); + } + + if (ret && ctx) { + if (ctx->stub_mem_pool) + mem_pool_destroy(ctx->stub_mem_pool); + if (ctx->dict_pool) + mem_pool_destroy(ctx->dict_pool); + if (ctx->dict_data_pool) + mem_pool_destroy(ctx->dict_data_pool); + if (ctx->dict_pair_pool) + mem_pool_destroy(ctx->dict_pair_pool); + if (ctx->logbuf_pool) + mem_pool_destroy(ctx->logbuf_pool); + } + return ret; +} static int -create_master (struct glfs *fs) +create_master(struct glfs *fs) { - int ret = 0; - xlator_t *master = NULL; - - master = GF_CALLOC (1, sizeof (*master), - glfs_mt_xlator_t); - if (!master) - goto err; - - master->name = gf_strdup ("gfapi"); - if (!master->name) - goto err; - - if (xlator_set_type (master, "mount/api") == -1) { - gf_msg ("glfs", GF_LOG_ERROR, 0, - API_MSG_MASTER_XLATOR_INIT_FAILED, "master xlator " - "for %s initialization failed", fs->volname); - goto err; - } - - master->ctx = fs->ctx; - master->private = fs; - master->options = get_new_dict (); - if (!master->options) - goto err; - - - ret = xlator_init (master); - if (ret) { - gf_msg ("glfs", GF_LOG_ERROR, 0, - API_MSG_GFAPI_XLATOR_INIT_FAILED, - "failed to initialize gfapi translator"); - goto err; - } - - fs->ctx->master = master; - THIS = master; - - return 0; + int ret = 0; + xlator_t *master = NULL; + + master = GF_CALLOC(1, sizeof(*master), glfs_mt_xlator_t); + if (!master) + goto err; + + master->name = gf_strdup("gfapi"); + if (!master->name) + goto err; + + if (xlator_set_type(master, "mount/api") == -1) { + gf_msg("glfs", GF_LOG_ERROR, 0, API_MSG_MASTER_XLATOR_INIT_FAILED, + "master xlator " + "for %s initialization failed", + fs->volname); + goto err; + } + + master->ctx = fs->ctx; + master->private = fs; + master->options = get_new_dict(); + if (!master->options) + goto err; + + ret = xlator_init(master); + if (ret) { + gf_msg("glfs", GF_LOG_ERROR, 0, API_MSG_GFAPI_XLATOR_INIT_FAILED, + "failed to initialize gfapi translator"); + goto err; + } + + fs->ctx->master = master; + THIS = master; + + return 0; err: - if (master) { - xlator_destroy (master); - } + if (master) { + xlator_destroy(master); + } - return -1; + return -1; } - static FILE * -get_volfp (struct glfs *fs) +get_volfp(struct glfs *fs) { - cmd_args_t *cmd_args = NULL; - FILE *specfp = NULL; + cmd_args_t *cmd_args = NULL; + FILE *specfp = NULL; - cmd_args = &fs->ctx->cmd_args; + cmd_args = &fs->ctx->cmd_args; - if ((specfp = fopen (cmd_args->volfile, "r")) == NULL) { - gf_msg ("glfs", GF_LOG_ERROR, errno, - API_MSG_VOLFILE_OPEN_FAILED, - "volume file %s open failed: %s", - cmd_args->volfile, - strerror (errno)); - return NULL; - } + if ((specfp = fopen(cmd_args->volfile, "r")) == NULL) { + gf_msg("glfs", GF_LOG_ERROR, errno, API_MSG_VOLFILE_OPEN_FAILED, + "volume file %s open failed: %s", cmd_args->volfile, + strerror(errno)); + return NULL; + } - gf_msg_debug ("glfs", 0, "loading volume file %s", cmd_args->volfile); + gf_msg_debug("glfs", 0, "loading volume file %s", cmd_args->volfile); - return specfp; + return specfp; } - int -glfs_volumes_init (struct glfs *fs) +glfs_volumes_init(struct glfs *fs) { - FILE *fp = NULL; - cmd_args_t *cmd_args = NULL; - int ret = 0; + FILE *fp = NULL; + cmd_args_t *cmd_args = NULL; + int ret = 0; - cmd_args = &fs->ctx->cmd_args; + cmd_args = &fs->ctx->cmd_args; - if (!vol_assigned (cmd_args)) - return -1; + if (!vol_assigned(cmd_args)) + return -1; - if (cmd_args->volfile_server) { - ret = glfs_mgmt_init (fs); - goto out; - } + if (cmd_args->volfile_server) { + ret = glfs_mgmt_init(fs); + goto out; + } - fp = get_volfp (fs); + fp = get_volfp(fs); - if (!fp) { - gf_msg ("glfs", GF_LOG_ERROR, ENOENT, - API_MSG_VOL_SPEC_FILE_ERROR, - "Cannot reach volume specification file"); - ret = -1; - goto out; - } + if (!fp) { + gf_msg("glfs", GF_LOG_ERROR, ENOENT, API_MSG_VOL_SPEC_FILE_ERROR, + "Cannot reach volume specification file"); + ret = -1; + goto out; + } - ret = glfs_process_volfp (fs, fp); - if (ret) - goto out; + ret = glfs_process_volfp(fs, fp); + if (ret) + goto out; out: - return ret; + return ret; } - /////////////////////////////////////////////////////////////////////////////// - int -pub_glfs_set_xlator_option (struct glfs *fs, const char *xlator, - const char *key, const char *value) +pub_glfs_set_xlator_option(struct glfs *fs, const char *xlator, const char *key, + const char *value) { - xlator_cmdline_option_t *option = NULL; + xlator_cmdline_option_t *option = NULL; - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - option = GF_CALLOC (1, sizeof (*option), - glfs_mt_xlator_cmdline_option_t); - if (!option) - goto enomem; + option = GF_CALLOC(1, sizeof(*option), glfs_mt_xlator_cmdline_option_t); + if (!option) + goto enomem; - INIT_LIST_HEAD (&option->cmd_args); + INIT_LIST_HEAD(&option->cmd_args); - option->volume = gf_strdup (xlator); - if (!option->volume) - goto enomem; - option->key = gf_strdup (key); - if (!option->key) - goto enomem; - option->value = gf_strdup (value); - if (!option->value) - goto enomem; + option->volume = gf_strdup(xlator); + if (!option->volume) + goto enomem; + option->key = gf_strdup(key); + if (!option->key) + goto enomem; + option->value = gf_strdup(value); + if (!option->value) + goto enomem; - list_add (&option->cmd_args, &fs->ctx->cmd_args.xlator_options); + list_add(&option->cmd_args, &fs->ctx->cmd_args.xlator_options); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; - return 0; + return 0; enomem: - errno = ENOMEM; + errno = ENOMEM; - if (!option) { - __GLFS_EXIT_FS; - return -1; - } + if (!option) { + __GLFS_EXIT_FS; + return -1; + } - GF_FREE (option->volume); - GF_FREE (option->key); - GF_FREE (option->value); - GF_FREE (option); + GF_FREE(option->volume); + GF_FREE(option->key); + GF_FREE(option->value); + GF_FREE(option); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return -1; + return -1; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_xlator_option, 3.4.0); - int -pub_glfs_unset_volfile_server (struct glfs *fs, const char *transport, - const char *host, const int port) +pub_glfs_unset_volfile_server(struct glfs *fs, const char *transport, + const char *host, const int port) { - cmd_args_t *cmd_args = NULL; - server_cmdline_t *server = NULL; - server_cmdline_t *tmp = NULL; - char *transport_val = NULL; - int port_val = 0; - int ret = -1; - - if (!fs || !host) { - errno = EINVAL; - return ret; - } - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - cmd_args = &fs->ctx->cmd_args; - - if (transport) { - transport_val = gf_strdup (transport); - } else { - transport_val = gf_strdup (GF_DEFAULT_VOLFILE_TRANSPORT); - } - - if (!transport_val) { - errno = ENOMEM; - goto out; - } - - if (port) { - port_val = port; - } else { - port_val = GF_DEFAULT_BASE_PORT; - } - - list_for_each_entry_safe (server, tmp, - &cmd_args->curr_server->list, - list) { - if ((!strcmp(server->volfile_server, host) && - !strcmp(server->transport, transport_val) && - (server->port == port_val))) { - list_del (&server->list); - ret = 0; - goto out; - } + cmd_args_t *cmd_args = NULL; + server_cmdline_t *server = NULL; + server_cmdline_t *tmp = NULL; + char *transport_val = NULL; + int port_val = 0; + int ret = -1; + + if (!fs || !host) { + errno = EINVAL; + return ret; + } + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + cmd_args = &fs->ctx->cmd_args; + + if (transport) { + transport_val = gf_strdup(transport); + } else { + transport_val = gf_strdup(GF_DEFAULT_VOLFILE_TRANSPORT); + } + + if (!transport_val) { + errno = ENOMEM; + goto out; + } + + if (port) { + port_val = port; + } else { + port_val = GF_DEFAULT_BASE_PORT; + } + + list_for_each_entry_safe(server, tmp, &cmd_args->curr_server->list, list) + { + if ((!strcmp(server->volfile_server, host) && + !strcmp(server->transport, transport_val) && + (server->port == port_val))) { + list_del(&server->list); + ret = 0; + goto out; } + } out: - GF_FREE (transport_val); - __GLFS_EXIT_FS; + GF_FREE(transport_val); + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_unset_volfile_server, 3.5.1); - int -pub_glfs_set_volfile_server (struct glfs *fs, const char *transport, - const char *host, int port) +pub_glfs_set_volfile_server(struct glfs *fs, const char *transport, + const char *host, int port) { - cmd_args_t *cmd_args = NULL; - int ret = -1; - char *server_host = NULL; - char *server_transport = NULL; - - if (!fs || !host) { - errno = EINVAL; - return ret; - } - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + cmd_args_t *cmd_args = NULL; + int ret = -1; + char *server_host = NULL; + char *server_transport = NULL; - cmd_args = &fs->ctx->cmd_args; - cmd_args->max_connect_attempts = 1; - - server_host = gf_strdup (host); - if (!server_host) { - errno = ENOMEM; - goto out; - } - - if (transport) { - /* volfile fetch support over tcp|unix only */ - if (!strcmp(transport, "tcp") || !strcmp(transport, "unix")) { - server_transport = gf_strdup (transport); - } else if (!strcmp(transport, "rdma")) { - server_transport = - gf_strdup (GF_DEFAULT_VOLFILE_TRANSPORT); - gf_msg ("glfs", GF_LOG_WARNING, EINVAL, - API_MSG_INVALID_ENTRY, - "transport RDMA is deprecated, " - "falling back to tcp"); - } else { - gf_msg ("glfs", GF_LOG_TRACE, EINVAL, - API_MSG_INVALID_ENTRY, - "transport %s is not supported, " - "possible values tcp|unix", - transport); - goto out; - } + if (!fs || !host) { + errno = EINVAL; + return ret; + } + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + cmd_args = &fs->ctx->cmd_args; + cmd_args->max_connect_attempts = 1; + + server_host = gf_strdup(host); + if (!server_host) { + errno = ENOMEM; + goto out; + } + + if (transport) { + /* volfile fetch support over tcp|unix only */ + if (!strcmp(transport, "tcp") || !strcmp(transport, "unix")) { + server_transport = gf_strdup(transport); + } else if (!strcmp(transport, "rdma")) { + server_transport = gf_strdup(GF_DEFAULT_VOLFILE_TRANSPORT); + gf_msg("glfs", GF_LOG_WARNING, EINVAL, API_MSG_INVALID_ENTRY, + "transport RDMA is deprecated, " + "falling back to tcp"); } else { - server_transport = gf_strdup (GF_DEFAULT_VOLFILE_TRANSPORT); - } - - if (!server_transport) { - errno = ENOMEM; - goto out; - } - - if (!port) { - port = GF_DEFAULT_BASE_PORT; - } - - if (!strcmp(server_transport, "unix")) { - port = 0; - } - - ret = gf_set_volfile_server_common(cmd_args, server_host, - server_transport, port); - if (ret) { - gf_log ("glfs", GF_LOG_ERROR, - "failed to set volfile server: %s", strerror (errno)); + gf_msg("glfs", GF_LOG_TRACE, EINVAL, API_MSG_INVALID_ENTRY, + "transport %s is not supported, " + "possible values tcp|unix", + transport); + goto out; } + } else { + server_transport = gf_strdup(GF_DEFAULT_VOLFILE_TRANSPORT); + } + + if (!server_transport) { + errno = ENOMEM; + goto out; + } + + if (!port) { + port = GF_DEFAULT_BASE_PORT; + } + + if (!strcmp(server_transport, "unix")) { + port = 0; + } + + ret = gf_set_volfile_server_common(cmd_args, server_host, server_transport, + port); + if (ret) { + gf_log("glfs", GF_LOG_ERROR, "failed to set volfile server: %s", + strerror(errno)); + } out: - if (server_host) { - GF_FREE (server_host); - } + if (server_host) { + GF_FREE(server_host); + } - if (server_transport) { - GF_FREE (server_transport); - } + if (server_transport) { + GF_FREE(server_transport); + } - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_volfile_server, 3.4.0); @@ -497,294 +474,288 @@ GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_volfile_server, 3.4.0); * Used to free the arguments allocated by glfs_set_volfile_server() */ static void -glfs_free_volfile_servers (cmd_args_t *cmd_args) +glfs_free_volfile_servers(cmd_args_t *cmd_args) { - server_cmdline_t *server = NULL; - server_cmdline_t *tmp = NULL; - - GF_VALIDATE_OR_GOTO (THIS->name, cmd_args, out); - - list_for_each_entry_safe (server, tmp, &cmd_args->volfile_servers, - list) { - list_del_init (&server->list); - GF_FREE (server->volfile_server); - GF_FREE (server->transport); - GF_FREE (server); - } - cmd_args->curr_server = NULL; + server_cmdline_t *server = NULL; + server_cmdline_t *tmp = NULL; + + GF_VALIDATE_OR_GOTO(THIS->name, cmd_args, out); + + list_for_each_entry_safe(server, tmp, &cmd_args->volfile_servers, list) + { + list_del_init(&server->list); + GF_FREE(server->volfile_server); + GF_FREE(server->transport); + GF_FREE(server); + } + cmd_args->curr_server = NULL; out: - return; + return; } static void -glfs_free_xlator_options (cmd_args_t *cmd_args) +glfs_free_xlator_options(cmd_args_t *cmd_args) { - xlator_cmdline_option_t *xo = NULL; - xlator_cmdline_option_t *tmp_xo = NULL; - - if (!&(cmd_args->xlator_options)) - return; - - list_for_each_entry_safe (xo, tmp_xo, &cmd_args->xlator_options, - cmd_args) { - list_del_init (&xo->cmd_args); - GF_FREE (xo->volume); - GF_FREE (xo->key); - GF_FREE (xo->value); - GF_FREE (xo); - } + xlator_cmdline_option_t *xo = NULL; + xlator_cmdline_option_t *tmp_xo = NULL; + + if (!&(cmd_args->xlator_options)) + return; + + list_for_each_entry_safe(xo, tmp_xo, &cmd_args->xlator_options, cmd_args) + { + list_del_init(&xo->cmd_args); + GF_FREE(xo->volume); + GF_FREE(xo->key); + GF_FREE(xo->value); + GF_FREE(xo); + } } int -pub_glfs_setfsuid (uid_t fsuid) +pub_glfs_setfsuid(uid_t fsuid) { - /* TODO: - * - Set the THIS and restore it appropriately - */ - return syncopctx_setfsuid (&fsuid); + /* TODO: + * - Set the THIS and restore it appropriately + */ + return syncopctx_setfsuid(&fsuid); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsuid, 3.4.2); - int -pub_glfs_setfsgid (gid_t fsgid) +pub_glfs_setfsgid(gid_t fsgid) { - /* TODO: - * - Set the THIS and restore it appropriately - */ - return syncopctx_setfsgid (&fsgid); + /* TODO: + * - Set the THIS and restore it appropriately + */ + return syncopctx_setfsgid(&fsgid); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsgid, 3.4.2); - int -pub_glfs_setfsgroups (size_t size, const gid_t *list) +pub_glfs_setfsgroups(size_t size, const gid_t *list) { - /* TODO: - * - Set the THIS and restore it appropriately - */ - return syncopctx_setfsgroups(size, list); + /* TODO: + * - Set the THIS and restore it appropriately + */ + return syncopctx_setfsgroups(size, list); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsgroups, 3.4.2); int -pub_glfs_setfsleaseid (glfs_leaseid_t leaseid) +pub_glfs_setfsleaseid(glfs_leaseid_t leaseid) { - int ret = -1; - char *gleaseid = NULL; + int ret = -1; + char *gleaseid = NULL; - GF_VALIDATE_OR_GOTO (THIS->name, leaseid, out); + GF_VALIDATE_OR_GOTO(THIS->name, leaseid, out); - gleaseid = gf_leaseid_get(); - if (gleaseid) { - memcpy (gleaseid, leaseid, LEASE_ID_SIZE); - ret = 0; - } + gleaseid = gf_leaseid_get(); + if (gleaseid) { + memcpy(gleaseid, leaseid, LEASE_ID_SIZE); + ret = 0; + } out: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsleaseid, 4.0.0); int -get_fop_attr_glfd (dict_t **fop_attr, struct glfs_fd *glfd) +get_fop_attr_glfd(dict_t **fop_attr, struct glfs_fd *glfd) { - char *leaseid = NULL; - int ret = 0; - gf_boolean_t dict_create = _gf_false; - - leaseid = GF_MALLOC (LEASE_ID_SIZE, gf_common_mt_char); - GF_CHECK_ALLOC_AND_LOG("gfapi", leaseid, ret, "lease id alloc failed", out); - memcpy (leaseid, glfd->lease_id, LEASE_ID_SIZE); - if (*fop_attr == NULL) { - *fop_attr = dict_new (); - dict_create = _gf_true; - } - GF_CHECK_ALLOC_AND_LOG("gfapi", *fop_attr, ret, "dict_new failed", out); - ret = dict_set_static_bin (*fop_attr, "lease-id", leaseid, LEASE_ID_SIZE); + char *leaseid = NULL; + int ret = 0; + gf_boolean_t dict_create = _gf_false; + + leaseid = GF_MALLOC(LEASE_ID_SIZE, gf_common_mt_char); + GF_CHECK_ALLOC_AND_LOG("gfapi", leaseid, ret, "lease id alloc failed", out); + memcpy(leaseid, glfd->lease_id, LEASE_ID_SIZE); + if (*fop_attr == NULL) { + *fop_attr = dict_new(); + dict_create = _gf_true; + } + GF_CHECK_ALLOC_AND_LOG("gfapi", *fop_attr, ret, "dict_new failed", out); + ret = dict_set_static_bin(*fop_attr, "lease-id", leaseid, LEASE_ID_SIZE); out: - if (ret) { - GF_FREE (leaseid); - if (dict_create) { - if (*fop_attr) - dict_unref (*fop_attr); - *fop_attr = NULL; - } + if (ret) { + GF_FREE(leaseid); + if (dict_create) { + if (*fop_attr) + dict_unref(*fop_attr); + *fop_attr = NULL; } - return ret; + } + return ret; } int -set_fop_attr_glfd (struct glfs_fd *glfd) +set_fop_attr_glfd(struct glfs_fd *glfd) { - char *lease_id = NULL; - int ret = -1; + char *lease_id = NULL; + int ret = -1; - lease_id = gf_existing_leaseid (); - if (lease_id) { - memcpy (glfd->lease_id, lease_id, LEASE_ID_SIZE); - ret = 0; - } - return ret; + lease_id = gf_existing_leaseid(); + if (lease_id) { + memcpy(glfd->lease_id, lease_id, LEASE_ID_SIZE); + ret = 0; + } + return ret; } int -get_fop_attr_thrd_key (dict_t **fop_attr) +get_fop_attr_thrd_key(dict_t **fop_attr) { - char *lease_id = NULL; - int ret = 0; - gf_boolean_t dict_create = _gf_false; - - lease_id = gf_existing_leaseid (); - if (lease_id) { - if (*fop_attr == NULL) { - *fop_attr = dict_new (); - dict_create = _gf_true; - } - GF_CHECK_ALLOC_AND_LOG("gfapi", *fop_attr, ret, "dict_new failed", out); - ret = dict_set_bin (*fop_attr, "lease-id", gf_strdup (lease_id), - LEASE_ID_SIZE); + char *lease_id = NULL; + int ret = 0; + gf_boolean_t dict_create = _gf_false; + + lease_id = gf_existing_leaseid(); + if (lease_id) { + if (*fop_attr == NULL) { + *fop_attr = dict_new(); + dict_create = _gf_true; } + GF_CHECK_ALLOC_AND_LOG("gfapi", *fop_attr, ret, "dict_new failed", out); + ret = dict_set_bin(*fop_attr, "lease-id", gf_strdup(lease_id), + LEASE_ID_SIZE); + } out: - if (ret && dict_create) { - if (*fop_attr) - dict_unref (*fop_attr); - *fop_attr = NULL; - } - return ret; + if (ret && dict_create) { + if (*fop_attr) + dict_unref(*fop_attr); + *fop_attr = NULL; + } + return ret; } void -unset_fop_attr (dict_t **fop_attr) +unset_fop_attr(dict_t **fop_attr) { - char *lease_id = NULL; - lease_id = gf_existing_leaseid (); - if (lease_id) - memset (lease_id, 0, LEASE_ID_SIZE); - if (*fop_attr) { - dict_unref (*fop_attr); - *fop_attr = NULL; - } + char *lease_id = NULL; + lease_id = gf_existing_leaseid(); + if (lease_id) + memset(lease_id, 0, LEASE_ID_SIZE); + if (*fop_attr) { + dict_unref(*fop_attr); + *fop_attr = NULL; + } } struct glfs * -pub_glfs_from_glfd (struct glfs_fd *glfd) +pub_glfs_from_glfd(struct glfs_fd *glfd) { - return glfd->fs; + return glfd->fs; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_from_glfd, 3.4.0); static void -glfs_fd_destroy (struct glfs_fd *glfd) +glfs_fd_destroy(struct glfs_fd *glfd) { - if (!glfd) - return; + if (!glfd) + return; - glfs_lock (glfd->fs, _gf_true); - { - list_del_init (&glfd->openfds); - } - glfs_unlock (glfd->fs); + glfs_lock(glfd->fs, _gf_true); + { + list_del_init(&glfd->openfds); + } + glfs_unlock(glfd->fs); - if (glfd->fd) { - fd_unref (glfd->fd); - glfd->fd = NULL; - } + if (glfd->fd) { + fd_unref(glfd->fd); + glfd->fd = NULL; + } - GF_FREE (glfd->readdirbuf); + GF_FREE(glfd->readdirbuf); - GF_FREE (glfd); + GF_FREE(glfd); } - struct glfs_fd * -glfs_fd_new (struct glfs *fs) +glfs_fd_new(struct glfs *fs) { - struct glfs_fd *glfd = NULL; + struct glfs_fd *glfd = NULL; - glfd = GF_CALLOC (1, sizeof (*glfd), glfs_mt_glfs_fd_t); - if (!glfd) - return NULL; + glfd = GF_CALLOC(1, sizeof(*glfd), glfs_mt_glfs_fd_t); + if (!glfd) + return NULL; - glfd->fs = fs; + glfd->fs = fs; - INIT_LIST_HEAD (&glfd->openfds); + INIT_LIST_HEAD(&glfd->openfds); - GF_REF_INIT (glfd, glfs_fd_destroy); + GF_REF_INIT(glfd, glfs_fd_destroy); - return glfd; + return glfd; } - void -glfs_fd_bind (struct glfs_fd *glfd) +glfs_fd_bind(struct glfs_fd *glfd) { - struct glfs *fs = NULL; + struct glfs *fs = NULL; - fs = glfd->fs; + fs = glfd->fs; - glfs_lock (fs, _gf_true); - { - list_add_tail (&glfd->openfds, &fs->openfds); - } - glfs_unlock (fs); + glfs_lock(fs, _gf_true); + { + list_add_tail(&glfd->openfds, &fs->openfds); + } + glfs_unlock(fs); } - static void * -glfs_poller (void *data) +glfs_poller(void *data) { - struct glfs *fs = NULL; + struct glfs *fs = NULL; - fs = data; + fs = data; - event_dispatch (fs->ctx->event_pool); + event_dispatch(fs->ctx->event_pool); - return NULL; + return NULL; } static struct glfs * -glfs_new_fs (const char *volname) +glfs_new_fs(const char *volname) { - struct glfs *fs = NULL; + struct glfs *fs = NULL; - fs = CALLOC (1, sizeof (*fs)); - if (!fs) - return NULL; + fs = CALLOC(1, sizeof(*fs)); + if (!fs) + return NULL; - INIT_LIST_HEAD (&fs->openfds); - INIT_LIST_HEAD (&fs->upcall_list); + INIT_LIST_HEAD(&fs->openfds); + INIT_LIST_HEAD(&fs->upcall_list); - PTHREAD_MUTEX_INIT (&fs->mutex, NULL, fs->pthread_flags, - GLFS_INIT_MUTEX, err); + PTHREAD_MUTEX_INIT(&fs->mutex, NULL, fs->pthread_flags, GLFS_INIT_MUTEX, + err); - PTHREAD_COND_INIT (&fs->cond, NULL, fs->pthread_flags, - GLFS_INIT_COND, err); + PTHREAD_COND_INIT(&fs->cond, NULL, fs->pthread_flags, GLFS_INIT_COND, err); - PTHREAD_COND_INIT (&fs->child_down_cond, NULL, fs->pthread_flags, - GLFS_INIT_COND_CHILD, err); + PTHREAD_COND_INIT(&fs->child_down_cond, NULL, fs->pthread_flags, + GLFS_INIT_COND_CHILD, err); - PTHREAD_MUTEX_INIT (&fs->upcall_list_mutex, NULL, fs->pthread_flags, - GLFS_INIT_MUTEX_UPCALL, err); + PTHREAD_MUTEX_INIT(&fs->upcall_list_mutex, NULL, fs->pthread_flags, + GLFS_INIT_MUTEX_UPCALL, err); - fs->volname = strdup (volname); - if (!fs->volname) - goto err; + fs->volname = strdup(volname); + if (!fs->volname) + goto err; - fs->pin_refcnt = 0; - fs->upcall_events = 0; - fs->up_cbk = NULL; - fs->up_data = NULL; + fs->pin_refcnt = 0; + fs->upcall_events = 0; + fs->up_cbk = NULL; + fs->up_data = NULL; - return fs; + return fs; err: - glfs_free_from_ctx (fs); - return NULL; + glfs_free_from_ctx(fs); + return NULL; } extern xlator_t global_xlator; @@ -792,785 +763,769 @@ extern glusterfs_ctx_t *global_ctx; extern pthread_mutex_t global_ctx_mutex; static int -glfs_init_global_ctx () +glfs_init_global_ctx() { - int ret = 0; - glusterfs_ctx_t *ctx = NULL; + int ret = 0; + glusterfs_ctx_t *ctx = NULL; - pthread_mutex_lock (&global_ctx_mutex); - { - if (global_xlator.ctx) - goto unlock; + pthread_mutex_lock(&global_ctx_mutex); + { + if (global_xlator.ctx) + goto unlock; - ctx = glusterfs_ctx_new (); - if (!ctx) { - ret = -1; - goto unlock; - } + ctx = glusterfs_ctx_new(); + if (!ctx) { + ret = -1; + goto unlock; + } - gf_log_globals_init (ctx, GF_LOG_NONE); + gf_log_globals_init(ctx, GF_LOG_NONE); - global_ctx = ctx; - global_xlator.ctx = global_ctx; + global_ctx = ctx; + global_xlator.ctx = global_ctx; - ret = glusterfs_ctx_defaults_init (ctx); - if (ret) { - global_ctx = NULL; - global_xlator.ctx = NULL; - goto unlock; - } + ret = glusterfs_ctx_defaults_init(ctx); + if (ret) { + global_ctx = NULL; + global_xlator.ctx = NULL; + goto unlock; } + } unlock: - pthread_mutex_unlock (&global_ctx_mutex); + pthread_mutex_unlock(&global_ctx_mutex); - if (ret) - FREE (ctx); + if (ret) + FREE(ctx); - return ret; + return ret; } - struct glfs * -pub_glfs_new (const char *volname) +pub_glfs_new(const char *volname) { - struct glfs *fs = NULL; - int ret = -1; - glusterfs_ctx_t *ctx = NULL; - xlator_t *old_THIS = NULL; - char pname[16] = ""; - char msg[32] = ""; - - if (!volname) { - errno = EINVAL; - return NULL; - } - - /* - * Do this as soon as possible in case something else depends on - * pool allocations. - */ - mem_pools_init_early (); - mem_pools_init_late (); + struct glfs *fs = NULL; + int ret = -1; + glusterfs_ctx_t *ctx = NULL; + xlator_t *old_THIS = NULL; + char pname[16] = ""; + char msg[32] = ""; + + if (!volname) { + errno = EINVAL; + return NULL; + } - fs = glfs_new_fs (volname); - if (!fs) - goto out; + /* + * Do this as soon as possible in case something else depends on + * pool allocations. + */ + mem_pools_init_early(); + mem_pools_init_late(); - ctx = glusterfs_ctx_new (); - if (!ctx) - goto out; + fs = glfs_new_fs(volname); + if (!fs) + goto out; - /* first globals init, for gf_mem_acct_enable_set () */ + ctx = glusterfs_ctx_new(); + if (!ctx) + goto out; - ret = glusterfs_globals_init (ctx); - if (ret) - goto out; + /* first globals init, for gf_mem_acct_enable_set () */ - old_THIS = THIS; - ret = glfs_init_global_ctx (); - if (ret) - goto out; + ret = glusterfs_globals_init(ctx); + if (ret) + goto out; - /* then ctx_defaults_init, for xlator_mem_acct_init(THIS) */ + old_THIS = THIS; + ret = glfs_init_global_ctx(); + if (ret) + goto out; - ret = glusterfs_ctx_defaults_init (ctx); - if (ret) - goto out; + /* then ctx_defaults_init, for xlator_mem_acct_init(THIS) */ - fs->ctx = ctx; - fs->ctx->process_mode = GF_CLIENT_PROCESS; + ret = glusterfs_ctx_defaults_init(ctx); + if (ret) + goto out; - ret = glfs_set_logging (fs, "/dev/null", 0); - if (ret) - goto out; + fs->ctx = ctx; + fs->ctx->process_mode = GF_CLIENT_PROCESS; - fs->ctx->cmd_args.volfile_id = gf_strdup (volname); - if (!(fs->ctx->cmd_args.volfile_id)) { - ret = -1; - goto out; - } + ret = glfs_set_logging(fs, "/dev/null", 0); + if (ret) + goto out; + fs->ctx->cmd_args.volfile_id = gf_strdup(volname); + if (!(fs->ctx->cmd_args.volfile_id)) { ret = -1; + goto out; + } + + ret = -1; #ifdef GF_LINUX_HOST_OS - ret = prctl (PR_GET_NAME, (unsigned long) pname, 0, 0, 0); + ret = prctl(PR_GET_NAME, (unsigned long)pname, 0, 0, 0); #endif - if (ret) - fs->ctx->cmd_args.process_name = gf_strdup ("gfapi"); - else { - snprintf (msg, sizeof(msg), "gfapi.%s", pname); - fs->ctx->cmd_args.process_name = gf_strdup (msg); - } - ret = 0; + if (ret) + fs->ctx->cmd_args.process_name = gf_strdup("gfapi"); + else { + snprintf(msg, sizeof(msg), "gfapi.%s", pname); + fs->ctx->cmd_args.process_name = gf_strdup(msg); + } + ret = 0; out: - if (ret) { - if (fs) { - glfs_fini (fs); - fs = NULL; - } else { - /* glfs_fini() calls mem_pools_fini() too */ - mem_pools_fini (); - } + if (ret) { + if (fs) { + glfs_fini(fs); + fs = NULL; + } else { + /* glfs_fini() calls mem_pools_fini() too */ + mem_pools_fini(); } + } - if (old_THIS) - THIS = old_THIS; + if (old_THIS) + THIS = old_THIS; - return fs; + return fs; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_new, 3.4.0); - struct glfs * -priv_glfs_new_from_ctx (glusterfs_ctx_t *ctx) +priv_glfs_new_from_ctx(glusterfs_ctx_t *ctx) { - struct glfs *fs = NULL; + struct glfs *fs = NULL; - if (!ctx) - goto out; + if (!ctx) + goto out; - fs = glfs_new_fs (""); - if (!fs) - goto out; + fs = glfs_new_fs(""); + if (!fs) + goto out; - fs->ctx = ctx; + fs->ctx = ctx; out: - return fs; + return fs; } GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_new_from_ctx, 3.7.0); - void -priv_glfs_free_from_ctx (struct glfs *fs) +priv_glfs_free_from_ctx(struct glfs *fs) { - upcall_entry *u_list = NULL; - upcall_entry *tmp = NULL; - - if (!fs) - return; - - /* cleanup upcall structures */ - list_for_each_entry_safe (u_list, tmp, - &fs->upcall_list, - upcall_list) { - list_del_init (&u_list->upcall_list); - GF_FREE (u_list->upcall_data.data); - GF_FREE (u_list); - } + upcall_entry *u_list = NULL; + upcall_entry *tmp = NULL; + + if (!fs) + return; - PTHREAD_MUTEX_DESTROY (&fs->mutex, fs->pthread_flags, GLFS_INIT_MUTEX); + /* cleanup upcall structures */ + list_for_each_entry_safe(u_list, tmp, &fs->upcall_list, upcall_list) + { + list_del_init(&u_list->upcall_list); + GF_FREE(u_list->upcall_data.data); + GF_FREE(u_list); + } - PTHREAD_COND_DESTROY (&fs->cond, fs->pthread_flags, GLFS_INIT_COND); + PTHREAD_MUTEX_DESTROY(&fs->mutex, fs->pthread_flags, GLFS_INIT_MUTEX); - PTHREAD_COND_DESTROY (&fs->child_down_cond, fs->pthread_flags, - GLFS_INIT_COND_CHILD); + PTHREAD_COND_DESTROY(&fs->cond, fs->pthread_flags, GLFS_INIT_COND); - PTHREAD_MUTEX_DESTROY (&fs->upcall_list_mutex, fs->pthread_flags, - GLFS_INIT_MUTEX_UPCALL); + PTHREAD_COND_DESTROY(&fs->child_down_cond, fs->pthread_flags, + GLFS_INIT_COND_CHILD); - if (fs->oldvolfile) - FREE (fs->oldvolfile); + PTHREAD_MUTEX_DESTROY(&fs->upcall_list_mutex, fs->pthread_flags, + GLFS_INIT_MUTEX_UPCALL); - FREE (fs->volname); + if (fs->oldvolfile) + FREE(fs->oldvolfile); - FREE (fs); + FREE(fs->volname); + + FREE(fs); } GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_free_from_ctx, 3.7.0); - int -pub_glfs_set_volfile (struct glfs *fs, const char *volfile) +pub_glfs_set_volfile(struct glfs *fs, const char *volfile) { - cmd_args_t *cmd_args = NULL; + cmd_args_t *cmd_args = NULL; - cmd_args = &fs->ctx->cmd_args; + cmd_args = &fs->ctx->cmd_args; - if (vol_assigned (cmd_args)) - return -1; + if (vol_assigned(cmd_args)) + return -1; - cmd_args->volfile = gf_strdup (volfile); - if (!cmd_args->volfile) - return -1; - return 0; + cmd_args->volfile = gf_strdup(volfile); + if (!cmd_args->volfile) + return -1; + return 0; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_volfile, 3.4.0); - int -pub_glfs_set_logging (struct glfs *fs, const char *logfile, int loglevel) +pub_glfs_set_logging(struct glfs *fs, const char *logfile, int loglevel) { - int ret = -1; - char *tmplog = NULL; + int ret = -1; + char *tmplog = NULL; - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - if (!logfile) { - ret = gf_set_log_file_path (&fs->ctx->cmd_args, fs->ctx); - if (ret) - goto out; - tmplog = fs->ctx->cmd_args.log_file; - } else { - tmplog = (char *)logfile; - } + if (!logfile) { + ret = gf_set_log_file_path(&fs->ctx->cmd_args, fs->ctx); + if (ret) + goto out; + tmplog = fs->ctx->cmd_args.log_file; + } else { + tmplog = (char *)logfile; + } - /* finish log set parameters before init */ - if (loglevel >= 0) - gf_log_set_loglevel (fs->ctx, loglevel); + /* finish log set parameters before init */ + if (loglevel >= 0) + gf_log_set_loglevel(fs->ctx, loglevel); - ret = gf_log_init (fs->ctx, tmplog, NULL); - if (ret) - goto out; + ret = gf_log_init(fs->ctx, tmplog, NULL); + if (ret) + goto out; - ret = gf_log_inject_timer_event (fs->ctx); - if (ret) - goto out; + ret = gf_log_inject_timer_event(fs->ctx); + if (ret) + goto out; out: - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_logging, 3.4.0); - int -glfs_init_wait (struct glfs *fs) +glfs_init_wait(struct glfs *fs) { - int ret = -1; - - /* Always a top-down call, use glfs_lock() */ - glfs_lock (fs, _gf_true); - { - while (!fs->init) - pthread_cond_wait (&fs->cond, - &fs->mutex); - ret = fs->ret; - errno = fs->err; - } - glfs_unlock (fs); - - return ret; + int ret = -1; + + /* Always a top-down call, use glfs_lock() */ + glfs_lock(fs, _gf_true); + { + while (!fs->init) + pthread_cond_wait(&fs->cond, &fs->mutex); + ret = fs->ret; + errno = fs->err; + } + glfs_unlock(fs); + + return ret; } - void -priv_glfs_init_done (struct glfs *fs, int ret) +priv_glfs_init_done(struct glfs *fs, int ret) { - glfs_init_cbk init_cbk; - - if (!fs) { - gf_msg ("glfs", GF_LOG_ERROR, EINVAL, API_MSG_GLFS_FSOBJ_NULL, - "fs is NULL"); - goto out; - } - - init_cbk = fs->init_cbk; - - /* Always a bottom-up call, use mutex_lock() */ - pthread_mutex_lock (&fs->mutex); - { - fs->init = 1; - fs->ret = ret; - fs->err = errno; - - if (!init_cbk) - pthread_cond_broadcast (&fs->cond); - } - pthread_mutex_unlock (&fs->mutex); - - if (init_cbk) - init_cbk (fs, ret); + glfs_init_cbk init_cbk; + + if (!fs) { + gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_GLFS_FSOBJ_NULL, + "fs is NULL"); + goto out; + } + + init_cbk = fs->init_cbk; + + /* Always a bottom-up call, use mutex_lock() */ + pthread_mutex_lock(&fs->mutex); + { + fs->init = 1; + fs->ret = ret; + fs->err = errno; + + if (!init_cbk) + pthread_cond_broadcast(&fs->cond); + } + pthread_mutex_unlock(&fs->mutex); + + if (init_cbk) + init_cbk(fs, ret); out: - return; + return; } GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_init_done, 3.4.0); - int -glfs_init_common (struct glfs *fs) +glfs_init_common(struct glfs *fs) { - int ret = -1; + int ret = -1; - ret = create_master (fs); - if (ret) - return ret; + ret = create_master(fs); + if (ret) + return ret; - ret = gf_thread_create (&fs->poller, NULL, glfs_poller, fs, "glfspoll"); - if (ret) - return ret; + ret = gf_thread_create(&fs->poller, NULL, glfs_poller, fs, "glfspoll"); + if (ret) + return ret; - ret = glfs_volumes_init (fs); - if (ret) - return ret; + ret = glfs_volumes_init(fs); + if (ret) + return ret; - fs->dev_id = gf_dm_hashfn (fs->volname, strlen (fs->volname)); - return ret; + fs->dev_id = gf_dm_hashfn(fs->volname, strlen(fs->volname)); + return ret; } - int -glfs_init_async (struct glfs *fs, glfs_init_cbk cbk) +glfs_init_async(struct glfs *fs, glfs_init_cbk cbk) { - int ret = -1; + int ret = -1; - if (!fs || !fs->ctx) { - gf_msg ("glfs", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY, - "fs is not properly initialized."); - errno = EINVAL; - return ret; - } + if (!fs || !fs->ctx) { + gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY, + "fs is not properly initialized."); + errno = EINVAL; + return ret; + } - fs->init_cbk = cbk; + fs->init_cbk = cbk; - ret = glfs_init_common (fs); + ret = glfs_init_common(fs); - return ret; + return ret; } - int -pub_glfs_init (struct glfs *fs) +pub_glfs_init(struct glfs *fs) { - int ret = -1; + int ret = -1; - DECLARE_OLD_THIS; + DECLARE_OLD_THIS; - if (!fs || !fs->ctx) { - gf_msg ("glfs", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY, - "fs is not properly initialized."); - errno = EINVAL; - return ret; - } + if (!fs || !fs->ctx) { + gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY, + "fs is not properly initialized."); + errno = EINVAL; + return ret; + } - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - ret = glfs_init_common (fs); - if (ret) - goto out; + ret = glfs_init_common(fs); + if (ret) + goto out; - ret = glfs_init_wait (fs); + ret = glfs_init_wait(fs); out: - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; - /* Set the initial current working directory to "/" */ - if (ret >= 0) { - ret = glfs_chdir (fs, "/"); - } + /* Set the initial current working directory to "/" */ + if (ret >= 0) { + ret = glfs_chdir(fs, "/"); + } invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_init, 3.4.0); static int -glusterfs_ctx_destroy (glusterfs_ctx_t *ctx) +glusterfs_ctx_destroy(glusterfs_ctx_t *ctx) { - call_pool_t *pool = NULL; - int ret = 0; - glusterfs_graph_t *trav_graph = NULL; - glusterfs_graph_t *tmp = NULL; - - if (ctx == NULL) - return 0; - - if (ctx->cmd_args.curr_server) - glfs_free_volfile_servers (&ctx->cmd_args); - - glfs_free_xlator_options (&ctx->cmd_args); - - /* For all the graphs, crawl through the xlator_t structs and free - * all its members except for the mem_acct member, - * as GF_FREE will be referencing it. - */ - list_for_each_entry_safe (trav_graph, tmp, &ctx->graphs, list) { - xlator_tree_free_members (trav_graph->first); - } - - /* Free the memory pool */ - if (ctx->stub_mem_pool) - mem_pool_destroy (ctx->stub_mem_pool); - if (ctx->dict_pool) - mem_pool_destroy (ctx->dict_pool); - if (ctx->dict_data_pool) - mem_pool_destroy (ctx->dict_data_pool); - if (ctx->dict_pair_pool) - mem_pool_destroy (ctx->dict_pair_pool); - if (ctx->logbuf_pool) - mem_pool_destroy (ctx->logbuf_pool); - - pool = ctx->pool; - if (pool) { - if (pool->frame_mem_pool) - mem_pool_destroy (pool->frame_mem_pool); - if (pool->stack_mem_pool) - mem_pool_destroy (pool->stack_mem_pool); - LOCK_DESTROY (&pool->lock); - GF_FREE (pool); - } - - /* Free the event pool */ - ret = event_pool_destroy (ctx->event_pool); - - /* Free the iobuf pool */ - iobuf_pool_destroy (ctx->iobuf_pool); - - GF_FREE (ctx->process_uuid); - GF_FREE (ctx->cmd_args.volfile_id); - GF_FREE (ctx->cmd_args.process_name); - - LOCK_DESTROY (&ctx->lock); - pthread_mutex_destroy (&ctx->notify_lock); - pthread_cond_destroy (&ctx->notify_cond); - - /* Free all the graph structs and its containing xlator_t structs - * from this point there should be no reference to GF_FREE/GF_CALLOC - * as it will try to access mem_acct and the below function would - * have freed the same. - */ - list_for_each_entry_safe (trav_graph, tmp, &ctx->graphs, list) { - glusterfs_graph_destroy_residual (trav_graph); - } - - FREE (ctx); - - return ret; + call_pool_t *pool = NULL; + int ret = 0; + glusterfs_graph_t *trav_graph = NULL; + glusterfs_graph_t *tmp = NULL; + + if (ctx == NULL) + return 0; + + if (ctx->cmd_args.curr_server) + glfs_free_volfile_servers(&ctx->cmd_args); + + glfs_free_xlator_options(&ctx->cmd_args); + + /* For all the graphs, crawl through the xlator_t structs and free + * all its members except for the mem_acct member, + * as GF_FREE will be referencing it. + */ + list_for_each_entry_safe(trav_graph, tmp, &ctx->graphs, list) + { + xlator_tree_free_members(trav_graph->first); + } + + /* Free the memory pool */ + if (ctx->stub_mem_pool) + mem_pool_destroy(ctx->stub_mem_pool); + if (ctx->dict_pool) + mem_pool_destroy(ctx->dict_pool); + if (ctx->dict_data_pool) + mem_pool_destroy(ctx->dict_data_pool); + if (ctx->dict_pair_pool) + mem_pool_destroy(ctx->dict_pair_pool); + if (ctx->logbuf_pool) + mem_pool_destroy(ctx->logbuf_pool); + + pool = ctx->pool; + if (pool) { + if (pool->frame_mem_pool) + mem_pool_destroy(pool->frame_mem_pool); + if (pool->stack_mem_pool) + mem_pool_destroy(pool->stack_mem_pool); + LOCK_DESTROY(&pool->lock); + GF_FREE(pool); + } + + /* Free the event pool */ + ret = event_pool_destroy(ctx->event_pool); + + /* Free the iobuf pool */ + iobuf_pool_destroy(ctx->iobuf_pool); + + GF_FREE(ctx->process_uuid); + GF_FREE(ctx->cmd_args.volfile_id); + GF_FREE(ctx->cmd_args.process_name); + + LOCK_DESTROY(&ctx->lock); + pthread_mutex_destroy(&ctx->notify_lock); + pthread_cond_destroy(&ctx->notify_cond); + + /* Free all the graph structs and its containing xlator_t structs + * from this point there should be no reference to GF_FREE/GF_CALLOC + * as it will try to access mem_acct and the below function would + * have freed the same. + */ + list_for_each_entry_safe(trav_graph, tmp, &ctx->graphs, list) + { + glusterfs_graph_destroy_residual(trav_graph); + } + + FREE(ctx); + + return ret; } int -pub_glfs_fini (struct glfs *fs) +pub_glfs_fini(struct glfs *fs) { - int ret = -1; - int countdown = 100; - xlator_t *subvol = NULL; - glusterfs_ctx_t *ctx = NULL; - glusterfs_graph_t *graph = NULL; - call_pool_t *call_pool = NULL; - int fs_init = 0; - int err = -1; - - DECLARE_OLD_THIS; - - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - ctx = fs->ctx; - if (!ctx) { - goto free_fs; - } - - if (ctx->mgmt) { - rpc_clnt_disable (ctx->mgmt); - rpc_clnt_unref (ctx->mgmt); - ctx->mgmt = NULL; - } - - call_pool = fs->ctx->pool; - - while (countdown--) { - /* give some time for background frames to finish */ - pthread_mutex_lock (&fs->mutex); - { - /* Do we need to increase countdown? */ - if ((!call_pool->cnt) && (!fs->pin_refcnt)) { - gf_msg_trace ("glfs", 0, - "call_pool_cnt - %"PRId64"," - "pin_refcnt - %d", - call_pool->cnt, fs->pin_refcnt); - - ctx->cleanup_started = 1; - pthread_mutex_unlock (&fs->mutex); - break; - } - } - pthread_mutex_unlock (&fs->mutex); - usleep (100000); - } - - /* leaked frames may exist, we ignore */ - - /*We deem glfs_fini as successful if there are no pending frames in the call - *pool*/ - ret = (call_pool->cnt == 0)? 0: -1; - - pthread_mutex_lock (&fs->mutex); + int ret = -1; + int countdown = 100; + xlator_t *subvol = NULL; + glusterfs_ctx_t *ctx = NULL; + glusterfs_graph_t *graph = NULL; + call_pool_t *call_pool = NULL; + int fs_init = 0; + int err = -1; + + DECLARE_OLD_THIS; + + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + ctx = fs->ctx; + if (!ctx) { + goto free_fs; + } + + if (ctx->mgmt) { + rpc_clnt_disable(ctx->mgmt); + rpc_clnt_unref(ctx->mgmt); + ctx->mgmt = NULL; + } + + call_pool = fs->ctx->pool; + + while (countdown--) { + /* give some time for background frames to finish */ + pthread_mutex_lock(&fs->mutex); { - fs_init = fs->init; + /* Do we need to increase countdown? */ + if ((!call_pool->cnt) && (!fs->pin_refcnt)) { + gf_msg_trace("glfs", 0, + "call_pool_cnt - %" PRId64 + "," + "pin_refcnt - %d", + call_pool->cnt, fs->pin_refcnt); + + ctx->cleanup_started = 1; + pthread_mutex_unlock(&fs->mutex); + break; + } } - pthread_mutex_unlock (&fs->mutex); - - if (fs_init != 0) { - subvol = glfs_active_subvol (fs); - if (subvol) { - /* PARENT_DOWN within glfs_subvol_done() is issued - only on graph switch (new graph should activiate - and decrement the extra @winds count taken in - glfs_graph_setup() - - Since we are explicitly destroying, - PARENT_DOWN is necessary - */ - xlator_notify (subvol, GF_EVENT_PARENT_DOWN, subvol, 0); - /* Here we wait for GF_EVENT_CHILD_DOWN before exiting, - in case of asynchrnous cleanup - */ - graph = subvol->graph; - err = pthread_mutex_lock (&fs->mutex); - if (err != 0) { - gf_msg ("glfs", GF_LOG_ERROR, err, - API_MSG_FSMUTEX_LOCK_FAILED, - "pthread lock on glfs mutex, " - "returned error: (%s)", strerror (err)); - goto fail; - } - /* check and wait for CHILD_DOWN for active subvol*/ - { - while (graph->used) { - err = pthread_cond_wait (&fs->child_down_cond, - &fs->mutex); - if (err != 0) - gf_msg ("glfs", GF_LOG_INFO, err, - API_MSG_COND_WAIT_FAILED, - "%s cond wait failed %s", - subvol->name, - strerror (err)); - } - } - - err = pthread_mutex_unlock (&fs->mutex); - if (err != 0) { - gf_msg ("glfs", GF_LOG_ERROR, err, - API_MSG_FSMUTEX_UNLOCK_FAILED, - "pthread unlock on glfs mutex, " - "returned error: (%s)", strerror (err)); - goto fail; - } + pthread_mutex_unlock(&fs->mutex); + usleep(100000); + } + + /* leaked frames may exist, we ignore */ + + /*We deem glfs_fini as successful if there are no pending frames in the call + *pool*/ + ret = (call_pool->cnt == 0) ? 0 : -1; + + pthread_mutex_lock(&fs->mutex); + { + fs_init = fs->init; + } + pthread_mutex_unlock(&fs->mutex); + + if (fs_init != 0) { + subvol = glfs_active_subvol(fs); + if (subvol) { + /* PARENT_DOWN within glfs_subvol_done() is issued + only on graph switch (new graph should activiate + and decrement the extra @winds count taken in + glfs_graph_setup() + + Since we are explicitly destroying, + PARENT_DOWN is necessary + */ + xlator_notify(subvol, GF_EVENT_PARENT_DOWN, subvol, 0); + /* Here we wait for GF_EVENT_CHILD_DOWN before exiting, + in case of asynchrnous cleanup + */ + graph = subvol->graph; + err = pthread_mutex_lock(&fs->mutex); + if (err != 0) { + gf_msg("glfs", GF_LOG_ERROR, err, API_MSG_FSMUTEX_LOCK_FAILED, + "pthread lock on glfs mutex, " + "returned error: (%s)", + strerror(err)); + goto fail; + } + /* check and wait for CHILD_DOWN for active subvol*/ + { + while (graph->used) { + err = pthread_cond_wait(&fs->child_down_cond, &fs->mutex); + if (err != 0) + gf_msg("glfs", GF_LOG_INFO, err, + API_MSG_COND_WAIT_FAILED, + "%s cond wait failed %s", subvol->name, + strerror(err)); } - glfs_subvol_done (fs, subvol); - } - - ctx->cleanup_started = 1; - - if (fs_init != 0) { - /* Destroy all the inode tables of all the graphs. - * NOTE: - * - inode objects should be destroyed before calling fini() - * of each xlator, as fini() and forget() of the xlators - * can share few common locks or data structures, calling - * fini first might destroy those required by forget - * ( eg: in quick-read) - * - The call to inode_table_destroy_all is not required when - * the cleanup during graph switch is implemented to perform - * inode table destroy. - */ - inode_table_destroy_all (ctx); - - /* Call fini() of all the xlators in the active graph - * NOTE: - * - xlator fini() should be called before destroying any of - * the threads. (eg: fini() in protocol-client uses timer - * thread) */ - glusterfs_graph_deactivate (ctx->active); - - /* Join the syncenv_processor threads and cleanup - * syncenv resources*/ - syncenv_destroy (ctx->env); - - /* Join the poller thread */ - if (event_dispatch_destroy (ctx->event_pool) < 0) - ret = -1; + } + + err = pthread_mutex_unlock(&fs->mutex); + if (err != 0) { + gf_msg("glfs", GF_LOG_ERROR, err, API_MSG_FSMUTEX_UNLOCK_FAILED, + "pthread unlock on glfs mutex, " + "returned error: (%s)", + strerror(err)); + goto fail; + } } - - /* log infra has to be brought down before destroying - * timer registry, as logging uses timer infra + glfs_subvol_done(fs, subvol); + } + + ctx->cleanup_started = 1; + + if (fs_init != 0) { + /* Destroy all the inode tables of all the graphs. + * NOTE: + * - inode objects should be destroyed before calling fini() + * of each xlator, as fini() and forget() of the xlators + * can share few common locks or data structures, calling + * fini first might destroy those required by forget + * ( eg: in quick-read) + * - The call to inode_table_destroy_all is not required when + * the cleanup during graph switch is implemented to perform + * inode table destroy. */ - if (gf_log_fini (ctx) != 0) - ret = -1; + inode_table_destroy_all(ctx); + + /* Call fini() of all the xlators in the active graph + * NOTE: + * - xlator fini() should be called before destroying any of + * the threads. (eg: fini() in protocol-client uses timer + * thread) */ + glusterfs_graph_deactivate(ctx->active); + + /* Join the syncenv_processor threads and cleanup + * syncenv resources*/ + syncenv_destroy(ctx->env); + + /* Join the poller thread */ + if (event_dispatch_destroy(ctx->event_pool) < 0) + ret = -1; + } + + /* log infra has to be brought down before destroying + * timer registry, as logging uses timer infra + */ + if (gf_log_fini(ctx) != 0) + ret = -1; - /* Join the timer thread */ - if (fs_init != 0) { - gf_timer_registry_destroy (ctx); - } + /* Join the timer thread */ + if (fs_init != 0) { + gf_timer_registry_destroy(ctx); + } - /* Destroy the context and the global pools */ - if (glusterfs_ctx_destroy (ctx) != 0) - ret = -1; + /* Destroy the context and the global pools */ + if (glusterfs_ctx_destroy(ctx) != 0) + ret = -1; free_fs: - glfs_free_from_ctx (fs); + glfs_free_from_ctx(fs); - /* - * Do this as late as possible in case anything else has (or - * grows) a dependency on mem-pool allocations. - */ - mem_pools_fini (); + /* + * Do this as late as possible in case anything else has (or + * grows) a dependency on mem-pool allocations. + */ + mem_pools_fini(); fail: - if (!ret) - ret = err; + if (!ret) + ret = err; - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fini, 3.4.0); - ssize_t -pub_glfs_get_volfile (struct glfs *fs, void *buf, size_t len) +pub_glfs_get_volfile(struct glfs *fs, void *buf, size_t len) { - ssize_t res = -1; + ssize_t res = -1; - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - glfs_lock(fs, _gf_true); - if (len >= fs->oldvollen) { - gf_msg_trace ("glfs", 0, "copying %zu to %p", len, buf); - memcpy(buf,fs->oldvolfile,len); - res = len; - } - else { - res = len - fs->oldvollen; - gf_msg_trace ("glfs", 0, "buffer is %zd too short", -res); - } - glfs_unlock(fs); + glfs_lock(fs, _gf_true); + if (len >= fs->oldvollen) { + gf_msg_trace("glfs", 0, "copying %zu to %p", len, buf); + memcpy(buf, fs->oldvolfile, len); + res = len; + } else { + res = len - fs->oldvollen; + gf_msg_trace("glfs", 0, "buffer is %zd too short", -res); + } + glfs_unlock(fs); - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return res; + return res; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_get_volfile, 3.6.0); int -priv_glfs_ipc (struct glfs *fs, int opcode, void *xd_in, void **xd_out) +priv_glfs_ipc(struct glfs *fs, int opcode, void *xd_in, void **xd_out) { - xlator_t *subvol = NULL; - int ret = -1; + xlator_t *subvol = NULL; + int ret = -1; - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - subvol = glfs_active_subvol (fs); - if (!subvol) { - ret = -1; - errno = EIO; - goto out; - } + subvol = glfs_active_subvol(fs); + if (!subvol) { + ret = -1; + errno = EIO; + goto out; + } - ret = syncop_ipc (subvol, opcode, (dict_t *) xd_in, (dict_t **) xd_out); - DECODE_SYNCOP_ERR (ret); + ret = syncop_ipc(subvol, opcode, (dict_t *)xd_in, (dict_t **)xd_out); + DECODE_SYNCOP_ERR(ret); out: - glfs_subvol_done (fs, subvol); - __GLFS_EXIT_FS; + glfs_subvol_done(fs, subvol); + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_ipc, 3.12.0); - void -pub_glfs_free (void *ptr) +pub_glfs_free(void *ptr) { - GLFS_FREE (ptr); + GLFS_FREE(ptr); } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_free, 3.7.16); - -struct glfs* -pub_glfs_upcall_get_fs (struct glfs_upcall *arg) +struct glfs * +pub_glfs_upcall_get_fs(struct glfs_upcall *arg) { - return arg->fs; + return arg->fs; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_get_fs, 3.7.16); enum glfs_upcall_reason -pub_glfs_upcall_get_reason (struct glfs_upcall *arg) +pub_glfs_upcall_get_reason(struct glfs_upcall *arg) { - return arg->reason; + return arg->reason; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_get_reason, 3.7.16); -void* -pub_glfs_upcall_get_event (struct glfs_upcall *arg) +void * +pub_glfs_upcall_get_event(struct glfs_upcall *arg) { - return arg->event; + return arg->event; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_get_event, 3.7.16); -struct glfs_object* -pub_glfs_upcall_inode_get_object (struct glfs_upcall_inode *arg) +struct glfs_object * +pub_glfs_upcall_inode_get_object(struct glfs_upcall_inode *arg) { - return arg->object; + return arg->object; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_object, 3.7.16); uint64_t -pub_glfs_upcall_inode_get_flags (struct glfs_upcall_inode *arg) +pub_glfs_upcall_inode_get_flags(struct glfs_upcall_inode *arg) { - return arg->flags; + return arg->flags; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_flags, 3.7.16); -struct stat* -pub_glfs_upcall_inode_get_stat (struct glfs_upcall_inode *arg) +struct stat * +pub_glfs_upcall_inode_get_stat(struct glfs_upcall_inode *arg) { - return &arg->buf; + return &arg->buf; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_stat, 3.7.16); uint64_t -pub_glfs_upcall_inode_get_expire (struct glfs_upcall_inode *arg) +pub_glfs_upcall_inode_get_expire(struct glfs_upcall_inode *arg) { - return arg->expire_time_attr; + return arg->expire_time_attr; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_expire, 3.7.16); -struct glfs_object* -pub_glfs_upcall_inode_get_pobject (struct glfs_upcall_inode *arg) +struct glfs_object * +pub_glfs_upcall_inode_get_pobject(struct glfs_upcall_inode *arg) { - return arg->p_object; + return arg->p_object; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_pobject, 3.7.16); -struct stat* -pub_glfs_upcall_inode_get_pstat (struct glfs_upcall_inode *arg) +struct stat * +pub_glfs_upcall_inode_get_pstat(struct glfs_upcall_inode *arg) { - return &arg->p_buf; + return &arg->p_buf; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_pstat, 3.7.16); -struct glfs_object* -pub_glfs_upcall_inode_get_oldpobject (struct glfs_upcall_inode *arg) +struct glfs_object * +pub_glfs_upcall_inode_get_oldpobject(struct glfs_upcall_inode *arg) { - return arg->oldp_object; + return arg->oldp_object; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_oldpobject, 3.7.16); -struct stat* -pub_glfs_upcall_inode_get_oldpstat (struct glfs_upcall_inode *arg) +struct stat * +pub_glfs_upcall_inode_get_oldpstat(struct glfs_upcall_inode *arg) { - return &arg->oldp_buf; + return &arg->oldp_buf; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_oldpstat, 3.7.16); - /*struct glfs_object* pub_glfs_upcall_lease_get_object (struct glfs_upcall_recall_inode *arg) { @@ -1581,169 +1536,166 @@ GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_lease_get_object, 4.0.0); */ uint32_t -pub_glfs_upcall_lease_get_lease_type (struct glfs_upcall_lease *arg) +pub_glfs_upcall_lease_get_lease_type(struct glfs_upcall_lease *arg) { - return arg->lease_type; + return arg->lease_type; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_lease_get_lease_type, 4.0.0); /* definitions of the GLFS_SYSRQ_* chars are in glfs.h */ static struct glfs_sysrq_help { - char sysrq; - char *msg; -} glfs_sysrq_help[] = { - { GLFS_SYSRQ_HELP, "(H)elp" }, - { GLFS_SYSRQ_STATEDUMP, "(S)tatedump" }, - { 0, NULL } -}; + char sysrq; + char *msg; +} glfs_sysrq_help[] = {{GLFS_SYSRQ_HELP, "(H)elp"}, + {GLFS_SYSRQ_STATEDUMP, "(S)tatedump"}, + {0, NULL}}; int -pub_glfs_sysrq (struct glfs *fs, char sysrq) +pub_glfs_sysrq(struct glfs *fs, char sysrq) { - glusterfs_ctx_t *ctx = NULL; - int ret = 0; - int msg_len; - char msg[1024] = {0,}; /* should not exceed 1024 chars */ - - if (!fs || !fs->ctx) { - ret = -1; - errno = EINVAL; - goto out; - } + glusterfs_ctx_t *ctx = NULL; + int ret = 0; + int msg_len; + char msg[1024] = { + 0, + }; /* should not exceed 1024 chars */ + + if (!fs || !fs->ctx) { + ret = -1; + errno = EINVAL; + goto out; + } - ctx = fs->ctx; + ctx = fs->ctx; - switch (sysrq) { - case GLFS_SYSRQ_HELP: - { - struct glfs_sysrq_help *usage = NULL; - - for (usage = glfs_sysrq_help; usage->sysrq; usage++) { - msg_len = strlen(msg); - snprintf (msg + msg_len, /* append to msg */ - sizeof (msg) - msg_len - 2, - /* - 2 for the " " + terminating \0 */ - " %s", usage->msg); - } + switch (sysrq) { + case GLFS_SYSRQ_HELP: { + struct glfs_sysrq_help *usage = NULL; - /* not really an 'error', but make sure it gets logged */ - gf_log ("glfs", GF_LOG_ERROR, "available events: %s", msg); + for (usage = glfs_sysrq_help; usage->sysrq; usage++) { + msg_len = strlen(msg); + snprintf(msg + msg_len, /* append to msg */ + sizeof(msg) - msg_len - 2, + /* - 2 for the " " + terminating \0 */ + " %s", usage->msg); + } - break; + /* not really an 'error', but make sure it gets logged */ + gf_log("glfs", GF_LOG_ERROR, "available events: %s", msg); + + break; } case GLFS_SYSRQ_STATEDUMP: - gf_proc_dump_info (SIGUSR1, ctx); - break; + gf_proc_dump_info(SIGUSR1, ctx); + break; default: - gf_msg ("glfs", GF_LOG_ERROR, ENOTSUP, API_MSG_INVALID_ENTRY, - "'%c' is not a valid sysrq", sysrq); - errno = ENOTSUP; - ret = -1; - } + gf_msg("glfs", GF_LOG_ERROR, ENOTSUP, API_MSG_INVALID_ENTRY, + "'%c' is not a valid sysrq", sysrq); + errno = ENOTSUP; + ret = -1; + } out: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_sysrq, 3.10.0); int -pub_glfs_upcall_register (struct glfs *fs, uint32_t event_list, - glfs_upcall_cbk cbk, void *data) +pub_glfs_upcall_register(struct glfs *fs, uint32_t event_list, + glfs_upcall_cbk cbk, void *data) { - int ret = 0; - - /* list of supported upcall events */ - uint32_t up_events = GLFS_EVENT_INODE_INVALIDATE; + int ret = 0; - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); + /* list of supported upcall events */ + uint32_t up_events = GLFS_EVENT_INODE_INVALIDATE; - GF_VALIDATE_OR_GOTO (THIS->name, cbk, out); + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); - /* Event list should be either GLFS_EVENT_ANY - * or list of supported individual events (up_events) - */ - if ((event_list != GLFS_EVENT_ANY) && - (event_list & ~up_events)) { - errno = EINVAL; - ret = -1; - gf_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG, - "invalid event_list (0x%08x)", event_list); - goto out; - } + GF_VALIDATE_OR_GOTO(THIS->name, cbk, out); - /* in case other thread does unregister */ - pthread_mutex_lock (&fs->mutex); - { - if (event_list & GLFS_EVENT_INODE_INVALIDATE) { - /* @todo: Check if features.cache-invalidation is - * enabled. - */ - fs->upcall_events |= GF_UPCALL_CACHE_INVALIDATION; - ret |= GF_UPCALL_CACHE_INVALIDATION; - } else if (event_list & GLFS_EVENT_INODE_INVALIDATE) { - fs->upcall_events |= GF_UPCALL_RECALL_LEASE; - ret |= GF_UPCALL_RECALL_LEASE; - } - /* Override cbk function if existing */ - fs->up_cbk = cbk; - fs->up_data = data; - fs->cache_upcalls = _gf_true; + /* Event list should be either GLFS_EVENT_ANY + * or list of supported individual events (up_events) + */ + if ((event_list != GLFS_EVENT_ANY) && (event_list & ~up_events)) { + errno = EINVAL; + ret = -1; + gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG, + "invalid event_list (0x%08x)", event_list); + goto out; + } + + /* in case other thread does unregister */ + pthread_mutex_lock(&fs->mutex); + { + if (event_list & GLFS_EVENT_INODE_INVALIDATE) { + /* @todo: Check if features.cache-invalidation is + * enabled. + */ + fs->upcall_events |= GF_UPCALL_CACHE_INVALIDATION; + ret |= GF_UPCALL_CACHE_INVALIDATION; + } else if (event_list & GLFS_EVENT_INODE_INVALIDATE) { + fs->upcall_events |= GF_UPCALL_RECALL_LEASE; + ret |= GF_UPCALL_RECALL_LEASE; } - pthread_mutex_unlock (&fs->mutex); + /* Override cbk function if existing */ + fs->up_cbk = cbk; + fs->up_data = data; + fs->cache_upcalls = _gf_true; + } + pthread_mutex_unlock(&fs->mutex); out: - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_register, 3.13.0); int -pub_glfs_upcall_unregister (struct glfs *fs, uint32_t event_list) +pub_glfs_upcall_unregister(struct glfs *fs, uint32_t event_list) { - int ret = 0; - /* list of supported upcall events */ - uint32_t up_events = GLFS_EVENT_INODE_INVALIDATE; - - DECLARE_OLD_THIS; - __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs); - - /* Event list should be either GLFS_EVENT_ANY - * or list of supported individual events (up_events) - */ - if ((event_list != GLFS_EVENT_ANY) && - (event_list & ~up_events)) { - errno = EINVAL; - ret = -1; - gf_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG, - "invalid event_list (0x%08x)", event_list); - goto out; + int ret = 0; + /* list of supported upcall events */ + uint32_t up_events = GLFS_EVENT_INODE_INVALIDATE; + + DECLARE_OLD_THIS; + __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs); + + /* Event list should be either GLFS_EVENT_ANY + * or list of supported individual events (up_events) + */ + if ((event_list != GLFS_EVENT_ANY) && (event_list & ~up_events)) { + errno = EINVAL; + ret = -1; + gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG, + "invalid event_list (0x%08x)", event_list); + goto out; + } + + pthread_mutex_lock(&fs->mutex); + { + if (event_list & GLFS_EVENT_INODE_INVALIDATE) { + fs->upcall_events &= ~GF_UPCALL_CACHE_INVALIDATION; + ret |= GF_UPCALL_CACHE_INVALIDATION; } - pthread_mutex_lock (&fs->mutex); - { - if (event_list & GLFS_EVENT_INODE_INVALIDATE) { - fs->upcall_events &= ~GF_UPCALL_CACHE_INVALIDATION; - ret |= GF_UPCALL_CACHE_INVALIDATION; - } - - /* If there are no upcall events registered, reset cbk */ - if (fs->upcall_events == 0) { - fs->up_cbk = NULL; - fs->up_data = NULL; - fs->cache_upcalls = _gf_false; - } + /* If there are no upcall events registered, reset cbk */ + if (fs->upcall_events == 0) { + fs->up_cbk = NULL; + fs->up_data = NULL; + fs->cache_upcalls = _gf_false; } - pthread_mutex_unlock (&fs->mutex); + } + pthread_mutex_unlock(&fs->mutex); out: - __GLFS_EXIT_FS; + __GLFS_EXIT_FS; invalid_fs: - return ret; + return ret; } GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_unregister, 3.13.0); -- cgit