diff options
author | Gluster Ant <bugzilla-bot@gluster.org> | 2018-09-12 17:52:45 +0530 |
---|---|---|
committer | Nigel Babu <nigelb@redhat.com> | 2018-09-12 17:52:45 +0530 |
commit | e16868dede6455cab644805af6fe1ac312775e13 (patch) | |
tree | 15aebdb4fff2d87cf8a72f836816b3aa634da58d /libglusterfs/src/store.c | |
parent | 45a71c0548b6fd2c757aa2e7b7671a1411948894 (diff) |
Land part 2 of clang-format changes
Change-Id: Ia84cc24c8924e6d22d02ac15f611c10e26db99b4
Signed-off-by: Nigel Babu <nigelb@redhat.com>
Diffstat (limited to 'libglusterfs/src/store.c')
-rw-r--r-- | libglusterfs/src/store.c | 1167 |
1 files changed, 588 insertions, 579 deletions
diff --git a/libglusterfs/src/store.c b/libglusterfs/src/store.c index 5172982149f..39ca3ec1c74 100644 --- a/libglusterfs/src/store.c +++ b/libglusterfs/src/store.c @@ -18,725 +18,734 @@ #include "syscall.h" #include "libglusterfs-messages.h" - int32_t -gf_store_mkdir (char *path) +gf_store_mkdir(char *path) { - int32_t ret = -1; + int32_t ret = -1; - ret = mkdir_p (path, 0777, _gf_true); + ret = mkdir_p(path, 0777, _gf_true); - if ((-1 == ret) && (EEXIST != errno)) { - gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, "mkdir()" - " failed on path %s.", path); - } else { - ret = 0; - } + if ((-1 == ret) && (EEXIST != errno)) { + gf_msg("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, + "mkdir()" + " failed on path %s.", + path); + } else { + ret = 0; + } - return ret; + return ret; } int32_t -gf_store_handle_create_on_absence (gf_store_handle_t **shandle, - char *path) +gf_store_handle_create_on_absence(gf_store_handle_t **shandle, char *path) { - GF_ASSERT (shandle); - int32_t ret = 0; + GF_ASSERT(shandle); + int32_t ret = 0; - if (*shandle == NULL) { - ret = gf_store_handle_new (path, shandle); + if (*shandle == NULL) { + ret = gf_store_handle_new(path, shandle); - if (ret) { - gf_msg ("", GF_LOG_ERROR, 0, - LG_MSG_STORE_HANDLE_CREATE_FAILED, "Unable to" - " create store handle for path: %s", path); - } + if (ret) { + gf_msg("", GF_LOG_ERROR, 0, LG_MSG_STORE_HANDLE_CREATE_FAILED, + "Unable to" + " create store handle for path: %s", + path); } - return ret; + } + return ret; } int32_t -gf_store_mkstemp (gf_store_handle_t *shandle) +gf_store_mkstemp(gf_store_handle_t *shandle) { - char tmppath[PATH_MAX] = {0,}; - - GF_VALIDATE_OR_GOTO ("store", shandle, out); - GF_VALIDATE_OR_GOTO ("store", shandle->path, out); - - snprintf (tmppath, sizeof (tmppath), "%s.tmp", shandle->path); - shandle->tmp_fd = open (tmppath, O_RDWR | O_CREAT | O_TRUNC, 0600); - if (shandle->tmp_fd < 0) { - gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, - "Failed to open %s.", tmppath); - } + char tmppath[PATH_MAX] = { + 0, + }; + + GF_VALIDATE_OR_GOTO("store", shandle, out); + GF_VALIDATE_OR_GOTO("store", shandle->path, out); + + snprintf(tmppath, sizeof(tmppath), "%s.tmp", shandle->path); + shandle->tmp_fd = open(tmppath, O_RDWR | O_CREAT | O_TRUNC, 0600); + if (shandle->tmp_fd < 0) { + gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, + "Failed to open %s.", tmppath); + } out: - return shandle->tmp_fd; + return shandle->tmp_fd; } int -gf_store_sync_direntry (char *path) +gf_store_sync_direntry(char *path) { - int ret = -1; - int dirfd = -1; - char *dir = NULL; - char *pdir = NULL; - xlator_t *this = NULL; - - this = THIS; - - dir = gf_strdup (path); - if (!dir) - goto out; - - pdir = dirname (dir); - dirfd = open (pdir, O_RDONLY); - if (dirfd == -1) { - gf_msg (this->name, GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, - "Failed to open directory %s.", pdir); - goto out; - } - - ret = sys_fsync (dirfd); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, - LG_MSG_DIR_OP_FAILED, "Failed to fsync %s.", pdir); - goto out; - } - - ret = 0; + int ret = -1; + int dirfd = -1; + char *dir = NULL; + char *pdir = NULL; + xlator_t *this = NULL; + + this = THIS; + + dir = gf_strdup(path); + if (!dir) + goto out; + + pdir = dirname(dir); + dirfd = open(pdir, O_RDONLY); + if (dirfd == -1) { + gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, + "Failed to open directory %s.", pdir); + goto out; + } + + ret = sys_fsync(dirfd); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, + "Failed to fsync %s.", pdir); + goto out; + } + + ret = 0; out: - if (dirfd >= 0) { - ret = sys_close (dirfd); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, - LG_MSG_DIR_OP_FAILED, "Failed to close %s", pdir); - } + if (dirfd >= 0) { + ret = sys_close(dirfd); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, + "Failed to close %s", pdir); } + } - if (dir) - GF_FREE (dir); + if (dir) + GF_FREE(dir); - return ret; + return ret; } int32_t -gf_store_rename_tmppath (gf_store_handle_t *shandle) +gf_store_rename_tmppath(gf_store_handle_t *shandle) { - int32_t ret = -1; - char tmppath[PATH_MAX] = {0,}; - - GF_VALIDATE_OR_GOTO ("store", shandle, out); - GF_VALIDATE_OR_GOTO ("store", shandle->path, out); - - ret = sys_fsync (shandle->tmp_fd); - if (ret) { - gf_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, - "Failed to fsync %s", shandle->path); - goto out; - } - snprintf (tmppath, sizeof (tmppath), "%s.tmp", shandle->path); - ret = sys_rename (tmppath, shandle->path); - if (ret) { - gf_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, - "Failed to rename %s to %s", tmppath, - shandle->path); - goto out; - } - - ret = gf_store_sync_direntry (tmppath); + int32_t ret = -1; + char tmppath[PATH_MAX] = { + 0, + }; + + GF_VALIDATE_OR_GOTO("store", shandle, out); + GF_VALIDATE_OR_GOTO("store", shandle->path, out); + + ret = sys_fsync(shandle->tmp_fd); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, + "Failed to fsync %s", shandle->path); + goto out; + } + snprintf(tmppath, sizeof(tmppath), "%s.tmp", shandle->path); + ret = sys_rename(tmppath, shandle->path); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, + "Failed to rename %s to %s", tmppath, shandle->path); + goto out; + } + + ret = gf_store_sync_direntry(tmppath); out: - if (shandle && shandle->tmp_fd >= 0) { - sys_close (shandle->tmp_fd); - shandle->tmp_fd = -1; - } - return ret; + if (shandle && shandle->tmp_fd >= 0) { + sys_close(shandle->tmp_fd); + shandle->tmp_fd = -1; + } + return ret; } int32_t -gf_store_unlink_tmppath (gf_store_handle_t *shandle) +gf_store_unlink_tmppath(gf_store_handle_t *shandle) { - int32_t ret = -1; - char tmppath[PATH_MAX] = {0,}; - - GF_VALIDATE_OR_GOTO ("store", shandle, out); - GF_VALIDATE_OR_GOTO ("store", shandle->path, out); - - snprintf (tmppath, sizeof (tmppath), "%s.tmp", shandle->path); - ret = sys_unlink (tmppath); - if (ret && (errno != ENOENT)) { - gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, - "Failed to mv %s to %s", tmppath, - shandle->path); - } else { - ret = 0; - } + int32_t ret = -1; + char tmppath[PATH_MAX] = { + 0, + }; + + GF_VALIDATE_OR_GOTO("store", shandle, out); + GF_VALIDATE_OR_GOTO("store", shandle->path, out); + + snprintf(tmppath, sizeof(tmppath), "%s.tmp", shandle->path); + ret = sys_unlink(tmppath); + if (ret && (errno != ENOENT)) { + gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, + "Failed to mv %s to %s", tmppath, shandle->path); + } else { + ret = 0; + } out: - if (shandle && shandle->tmp_fd >= 0) { - sys_close (shandle->tmp_fd); - shandle->tmp_fd = -1; - } - return ret; + if (shandle && shandle->tmp_fd >= 0) { + sys_close(shandle->tmp_fd); + shandle->tmp_fd = -1; + } + return ret; } int -gf_store_read_and_tokenize (FILE *file, char *str, int size, char **iter_key, - char **iter_val, gf_store_op_errno_t *store_errno) +gf_store_read_and_tokenize(FILE *file, char *str, int size, char **iter_key, + char **iter_val, gf_store_op_errno_t *store_errno) { - int32_t ret = -1; - char *savetok = NULL; - char *key = NULL; - char *value = NULL; - char *temp = NULL; - size_t str_len = 0; - - GF_ASSERT (file); - GF_ASSERT (str); - GF_ASSERT (iter_key); - GF_ASSERT (iter_val); - GF_ASSERT (store_errno); + int32_t ret = -1; + char *savetok = NULL; + char *key = NULL; + char *value = NULL; + char *temp = NULL; + size_t str_len = 0; + + GF_ASSERT(file); + GF_ASSERT(str); + GF_ASSERT(iter_key); + GF_ASSERT(iter_val); + GF_ASSERT(store_errno); retry: - temp = fgets (str, size, file); - if (temp == NULL || feof (file)) { - ret = -1; - *store_errno = GD_STORE_EOF; - goto out; - } - - if (strcmp (str, "\n") == 0) - goto retry; - - str_len = strlen(str); - str[str_len - 1] = '\0'; - /* Truncate the "\n", as fgets stores "\n" in str */ - - key = strtok_r (str, "=", &savetok); - if (!key) { - ret = -1; - *store_errno = GD_STORE_KEY_NULL; - goto out; - } - - value = strtok_r (NULL, "", &savetok); - if (!value) { - ret = -1; - *store_errno = GD_STORE_VALUE_NULL; - goto out; - } - - *iter_key = key; - *iter_val = value; - *store_errno = GD_STORE_SUCCESS; - ret = 0; + temp = fgets(str, size, file); + if (temp == NULL || feof(file)) { + ret = -1; + *store_errno = GD_STORE_EOF; + goto out; + } + + if (strcmp(str, "\n") == 0) + goto retry; + + str_len = strlen(str); + str[str_len - 1] = '\0'; + /* Truncate the "\n", as fgets stores "\n" in str */ + + key = strtok_r(str, "=", &savetok); + if (!key) { + ret = -1; + *store_errno = GD_STORE_KEY_NULL; + goto out; + } + + value = strtok_r(NULL, "", &savetok); + if (!value) { + ret = -1; + *store_errno = GD_STORE_VALUE_NULL; + goto out; + } + + *iter_key = key; + *iter_val = value; + *store_errno = GD_STORE_SUCCESS; + ret = 0; out: - return ret; + return ret; } int32_t -gf_store_retrieve_value (gf_store_handle_t *handle, char *key, char **value) +gf_store_retrieve_value(gf_store_handle_t *handle, char *key, char **value) { - int32_t ret = -1; - char *scan_str = NULL; - char *iter_key = NULL; - char *iter_val = NULL; - char *free_str = NULL; - struct stat st = {0,}; - gf_store_op_errno_t store_errno = GD_STORE_SUCCESS; - - GF_ASSERT (handle); - - if (handle->locked == F_ULOCK) - /* no locking is used handle->fd gets closed() after usage */ - handle->fd = open (handle->path, O_RDWR); - else - /* handle->fd is valid already, kept open for lockf() */ - sys_lseek (handle->fd, 0, SEEK_SET); - - if (handle->fd == -1) { - gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, - "Unable to open file %s", handle->path); - goto out; - } + int32_t ret = -1; + char *scan_str = NULL; + char *iter_key = NULL; + char *iter_val = NULL; + char *free_str = NULL; + struct stat st = { + 0, + }; + gf_store_op_errno_t store_errno = GD_STORE_SUCCESS; + + GF_ASSERT(handle); + + if (handle->locked == F_ULOCK) + /* no locking is used handle->fd gets closed() after usage */ + handle->fd = open(handle->path, O_RDWR); + else + /* handle->fd is valid already, kept open for lockf() */ + sys_lseek(handle->fd, 0, SEEK_SET); + + if (handle->fd == -1) { + gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, + "Unable to open file %s", handle->path); + goto out; + } + if (!handle->read) { + int duped_fd = dup(handle->fd); + + if (duped_fd >= 0) + handle->read = fdopen(duped_fd, "r"); if (!handle->read) { - int duped_fd = dup(handle->fd); - - if (duped_fd >= 0) - handle->read = fdopen (duped_fd, "r"); - if (!handle->read) { - if (duped_fd != -1) - sys_close (duped_fd); - gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, - "Unable to open file %s", handle->path); - goto out; - } - } else { - fseek (handle->read, 0, SEEK_SET); - } - ret = sys_fstat (handle->fd, &st); + if (duped_fd != -1) + sys_close(duped_fd); + gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, + "Unable to open file %s", handle->path); + goto out; + } + } else { + fseek(handle->read, 0, SEEK_SET); + } + ret = sys_fstat(handle->fd, &st); + if (ret < 0) { + gf_msg("", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED, + "stat on file %s failed", handle->path); + ret = -1; + store_errno = GD_STORE_STAT_FAILED; + goto out; + } + + /* "st.st_size + 1" is used as we are fetching each + * line of a file using fgets, fgets will append "\0" + * to the end of the string + */ + scan_str = GF_CALLOC(1, st.st_size + 1, gf_common_mt_char); + + if (scan_str == NULL) { + ret = -1; + store_errno = GD_STORE_ENOMEM; + goto out; + } + + free_str = scan_str; + + do { + ret = gf_store_read_and_tokenize(handle->read, scan_str, st.st_size + 1, + &iter_key, &iter_val, &store_errno); if (ret < 0) { - gf_msg ("", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED, - "stat on file %s failed", handle->path); - ret = -1; - store_errno = GD_STORE_STAT_FAILED; - goto out; + gf_msg_trace("", 0, + "error while reading key '%s': " + "%s", + key, gf_store_strerror(store_errno)); + goto out; } - /* "st.st_size + 1" is used as we are fetching each - * line of a file using fgets, fgets will append "\0" - * to the end of the string - */ - scan_str = GF_CALLOC (1, st.st_size + 1, - gf_common_mt_char); - - if (scan_str == NULL) { - ret = -1; - store_errno = GD_STORE_ENOMEM; - goto out; - } + gf_msg_trace("", 0, "key %s read", iter_key); - free_str = scan_str; - - do { - ret = gf_store_read_and_tokenize (handle->read, scan_str, - st.st_size + 1, - &iter_key, &iter_val, - &store_errno); - if (ret < 0) { - gf_msg_trace ("", 0, "error while reading key '%s': " - "%s", key, - gf_store_strerror (store_errno)); - goto out; - } - - gf_msg_trace ("", 0, "key %s read", iter_key); - - if (!strcmp (key, iter_key)) { - gf_msg_debug ("", 0, "key %s found", key); - ret = 0; - if (iter_val) - *value = gf_strdup (iter_val); - goto out; - } - } while (1); -out: - if (handle->read) { - fclose (handle->read); - handle->read = NULL; + if (!strcmp(key, iter_key)) { + gf_msg_debug("", 0, "key %s found", key); + ret = 0; + if (iter_val) + *value = gf_strdup(iter_val); + goto out; } + } while (1); +out: + if (handle->read) { + fclose(handle->read); + handle->read = NULL; + } - if (handle->fd > 0 && handle->locked == F_ULOCK) { - /* only invalidate handle->fd if not locked */ - sys_close (handle->fd); - } + if (handle->fd > 0 && handle->locked == F_ULOCK) { + /* only invalidate handle->fd if not locked */ + sys_close(handle->fd); + } - GF_FREE (free_str); + GF_FREE(free_str); - return ret; + return ret; } int32_t -gf_store_save_value (int fd, char *key, char *value) +gf_store_save_value(int fd, char *key, char *value) { - int32_t ret = -1; - int dup_fd = -1; - FILE *fp = NULL; - - GF_ASSERT (fd > 0); - GF_ASSERT (key); - GF_ASSERT (value); - - dup_fd = dup (fd); - if (dup_fd == -1) - goto out; - - fp = fdopen (dup_fd, "a+"); - if (fp == NULL) { - gf_msg (THIS->name, GF_LOG_WARNING, errno, - LG_MSG_FILE_OP_FAILED, "fdopen failed."); - ret = -1; - goto out; - } - - ret = fprintf (fp, "%s=%s\n", key, value); - if (ret < 0) { - gf_msg (THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED, - "Unable to store key: %s, value: %s.", - key, value); - ret = -1; - goto out; - } - - ret = fflush (fp); - if (ret) { - gf_msg (THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED, - "fflush failed."); - ret = -1; - goto out; - } - - ret = 0; + int32_t ret = -1; + int dup_fd = -1; + FILE *fp = NULL; + + GF_ASSERT(fd > 0); + GF_ASSERT(key); + GF_ASSERT(value); + + dup_fd = dup(fd); + if (dup_fd == -1) + goto out; + + fp = fdopen(dup_fd, "a+"); + if (fp == NULL) { + gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED, + "fdopen failed."); + ret = -1; + goto out; + } + + ret = fprintf(fp, "%s=%s\n", key, value); + if (ret < 0) { + gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED, + "Unable to store key: %s, value: %s.", key, value); + ret = -1; + goto out; + } + + ret = fflush(fp); + if (ret) { + gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED, + "fflush failed."); + ret = -1; + goto out; + } + + ret = 0; out: - if (fp) - fclose (fp); + if (fp) + fclose(fp); - gf_msg_debug (THIS->name, 0, "returning: %d", ret); - return ret; + gf_msg_debug(THIS->name, 0, "returning: %d", ret); + return ret; } int32_t -gf_store_handle_new (const char *path, gf_store_handle_t **handle) +gf_store_handle_new(const char *path, gf_store_handle_t **handle) { - int32_t ret = -1; - gf_store_handle_t *shandle = NULL; - int fd = -1; - char *spath = NULL; - - shandle = GF_CALLOC (1, sizeof (*shandle), gf_common_mt_store_handle_t); - if (!shandle) - goto out; - - spath = gf_strdup (path); - if (!spath) - goto out; - - fd = open (path, O_RDWR | O_CREAT | O_APPEND, 0600); - if (fd < 0) { - gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, - "Failed to open file: %s.", path); - goto out; - } - - ret = gf_store_sync_direntry (spath); - if (ret) - goto out; - - shandle->path = spath; - shandle->locked = F_ULOCK; - *handle = shandle; - shandle->tmp_fd = -1; - - ret = 0; + int32_t ret = -1; + gf_store_handle_t *shandle = NULL; + int fd = -1; + char *spath = NULL; + + shandle = GF_CALLOC(1, sizeof(*shandle), gf_common_mt_store_handle_t); + if (!shandle) + goto out; + + spath = gf_strdup(path); + if (!spath) + goto out; + + fd = open(path, O_RDWR | O_CREAT | O_APPEND, 0600); + if (fd < 0) { + gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, + "Failed to open file: %s.", path); + goto out; + } + + ret = gf_store_sync_direntry(spath); + if (ret) + goto out; + + shandle->path = spath; + shandle->locked = F_ULOCK; + *handle = shandle; + shandle->tmp_fd = -1; + + ret = 0; out: - if (fd >= 0) - sys_close (fd); + if (fd >= 0) + sys_close(fd); - if (ret < 0) { - GF_FREE (spath); - GF_FREE (shandle); - } + if (ret < 0) { + GF_FREE(spath); + GF_FREE(shandle); + } - gf_msg_debug ("", 0, "Returning %d", ret); - return ret; + gf_msg_debug("", 0, "Returning %d", ret); + return ret; } int -gf_store_handle_retrieve (char *path, gf_store_handle_t **handle) +gf_store_handle_retrieve(char *path, gf_store_handle_t **handle) { - int32_t ret = -1; - struct stat statbuf = {0}; - - ret = sys_stat (path, &statbuf); - if (ret) { - gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_PATH_NOT_FOUND, "Path " - "corresponding to %s.", path); - goto out; - } - ret = gf_store_handle_new (path, handle); + int32_t ret = -1; + struct stat statbuf = {0}; + + ret = sys_stat(path, &statbuf); + if (ret) { + gf_msg("", GF_LOG_ERROR, errno, LG_MSG_PATH_NOT_FOUND, + "Path " + "corresponding to %s.", + path); + goto out; + } + ret = gf_store_handle_new(path, handle); out: - gf_msg_debug ("", 0, "Returning %d", ret); - return ret; + gf_msg_debug("", 0, "Returning %d", ret); + return ret; } int32_t -gf_store_handle_destroy (gf_store_handle_t *handle) +gf_store_handle_destroy(gf_store_handle_t *handle) { - int32_t ret = -1; + int32_t ret = -1; - if (!handle) { - ret = 0; - goto out; - } + if (!handle) { + ret = 0; + goto out; + } - GF_FREE (handle->path); + GF_FREE(handle->path); - GF_FREE (handle); + GF_FREE(handle); - ret = 0; + ret = 0; out: - gf_msg_debug ("", 0, "Returning %d", ret); + gf_msg_debug("", 0, "Returning %d", ret); - return ret; + return ret; } int32_t -gf_store_iter_new (gf_store_handle_t *shandle, gf_store_iter_t **iter) +gf_store_iter_new(gf_store_handle_t *shandle, gf_store_iter_t **iter) { - int32_t ret = -1; - FILE *fp = NULL; - gf_store_iter_t *tmp_iter = NULL; - - GF_ASSERT (shandle); - GF_ASSERT (iter); - - fp = fopen (shandle->path, "r"); - if (!fp) { - gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, - "Unable to open file %s", shandle->path); - goto out; - } + int32_t ret = -1; + FILE *fp = NULL; + gf_store_iter_t *tmp_iter = NULL; - tmp_iter = GF_CALLOC (1, sizeof (*tmp_iter), - gf_common_mt_store_iter_t); - if (!tmp_iter) - goto out; + GF_ASSERT(shandle); + GF_ASSERT(iter); - if (snprintf (tmp_iter->filepath, sizeof (tmp_iter->filepath), "%s", - shandle->path) >= sizeof (tmp_iter->filepath)) - goto out; + fp = fopen(shandle->path, "r"); + if (!fp) { + gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, + "Unable to open file %s", shandle->path); + goto out; + } - tmp_iter->file = fp; + tmp_iter = GF_CALLOC(1, sizeof(*tmp_iter), gf_common_mt_store_iter_t); + if (!tmp_iter) + goto out; - *iter = tmp_iter; - tmp_iter = NULL; - ret = 0; + if (snprintf(tmp_iter->filepath, sizeof(tmp_iter->filepath), "%s", + shandle->path) >= sizeof(tmp_iter->filepath)) + goto out; + + tmp_iter->file = fp; + + *iter = tmp_iter; + tmp_iter = NULL; + ret = 0; out: - if (ret && fp) - fclose (fp); + if (ret && fp) + fclose(fp); - GF_FREE (tmp_iter); + GF_FREE(tmp_iter); - gf_msg_debug ("", 0, "Returning with %d", ret); - return ret; + gf_msg_debug("", 0, "Returning with %d", ret); + return ret; } int32_t -gf_store_validate_key_value (char *storepath, char *key, char *val, - gf_store_op_errno_t *op_errno) +gf_store_validate_key_value(char *storepath, char *key, char *val, + gf_store_op_errno_t *op_errno) { - int ret = 0; - - GF_ASSERT (op_errno); - GF_ASSERT (storepath); - - if ((key == NULL) && (val == NULL)) { - ret = -1; - gf_msg ("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "Glusterd " - "store may be corrupted, Invalid key and value (null)" - " in %s", storepath); - *op_errno = GD_STORE_KEY_VALUE_NULL; - } else if (key == NULL) { - ret = -1; - gf_msg ("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "Glusterd " - "store may be corrupted, Invalid key (null) in %s", - storepath); - *op_errno = GD_STORE_KEY_NULL; - } else if (val == NULL) { - ret = -1; - gf_msg ("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "Glusterd " - "store may be corrupted, Invalid value (null) for key" - " %s in %s", key, storepath); - *op_errno = GD_STORE_VALUE_NULL; - } else { - ret = 0; - *op_errno = GD_STORE_SUCCESS; - } + int ret = 0; + + GF_ASSERT(op_errno); + GF_ASSERT(storepath); + + if ((key == NULL) && (val == NULL)) { + ret = -1; + gf_msg("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, + "Glusterd " + "store may be corrupted, Invalid key and value (null)" + " in %s", + storepath); + *op_errno = GD_STORE_KEY_VALUE_NULL; + } else if (key == NULL) { + ret = -1; + gf_msg("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, + "Glusterd " + "store may be corrupted, Invalid key (null) in %s", + storepath); + *op_errno = GD_STORE_KEY_NULL; + } else if (val == NULL) { + ret = -1; + gf_msg("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, + "Glusterd " + "store may be corrupted, Invalid value (null) for key" + " %s in %s", + key, storepath); + *op_errno = GD_STORE_VALUE_NULL; + } else { + ret = 0; + *op_errno = GD_STORE_SUCCESS; + } - return ret; + return ret; } int32_t -gf_store_iter_get_next (gf_store_iter_t *iter, char **key, char **value, - gf_store_op_errno_t *op_errno) +gf_store_iter_get_next(gf_store_iter_t *iter, char **key, char **value, + gf_store_op_errno_t *op_errno) { - int32_t ret = -1; - char *scan_str = NULL; - char *iter_key = NULL; - char *iter_val = NULL; - struct stat st = {0,}; - gf_store_op_errno_t store_errno = GD_STORE_SUCCESS; - - GF_ASSERT (iter); - GF_ASSERT (key); - GF_ASSERT (value); - - ret = sys_stat (iter->filepath, &st); - if (ret < 0) { - gf_msg ("", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED, - "stat on file failed"); - ret = -1; - store_errno = GD_STORE_STAT_FAILED; - goto out; - } - - /* "st.st_size + 1" is used as we are fetching each - * line of a file using fgets, fgets will append "\0" - * to the end of the string - */ - scan_str = GF_CALLOC (1, st.st_size + 1, - gf_common_mt_char); - if (!scan_str) { - ret = -1; - store_errno = GD_STORE_ENOMEM; - goto out; - } - - ret = gf_store_read_and_tokenize (iter->file, scan_str, - st.st_size + 1, - &iter_key, &iter_val, - &store_errno); - if (ret < 0) { - goto out; - } - - ret = gf_store_validate_key_value (iter->filepath, iter_key, - iter_val, &store_errno); - if (ret) - goto out; - - *key = gf_strdup (iter_key); - if (!*key) { - ret = -1; - store_errno = GD_STORE_ENOMEM; - goto out; - } - *value = gf_strdup (iter_val); - if (!*value) { - ret = -1; - store_errno = GD_STORE_ENOMEM; - goto out; - } - ret = 0; + int32_t ret = -1; + char *scan_str = NULL; + char *iter_key = NULL; + char *iter_val = NULL; + struct stat st = { + 0, + }; + gf_store_op_errno_t store_errno = GD_STORE_SUCCESS; + + GF_ASSERT(iter); + GF_ASSERT(key); + GF_ASSERT(value); + + ret = sys_stat(iter->filepath, &st); + if (ret < 0) { + gf_msg("", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED, + "stat on file failed"); + ret = -1; + store_errno = GD_STORE_STAT_FAILED; + goto out; + } + + /* "st.st_size + 1" is used as we are fetching each + * line of a file using fgets, fgets will append "\0" + * to the end of the string + */ + scan_str = GF_CALLOC(1, st.st_size + 1, gf_common_mt_char); + if (!scan_str) { + ret = -1; + store_errno = GD_STORE_ENOMEM; + goto out; + } + + ret = gf_store_read_and_tokenize(iter->file, scan_str, st.st_size + 1, + &iter_key, &iter_val, &store_errno); + if (ret < 0) { + goto out; + } + + ret = gf_store_validate_key_value(iter->filepath, iter_key, iter_val, + &store_errno); + if (ret) + goto out; + + *key = gf_strdup(iter_key); + if (!*key) { + ret = -1; + store_errno = GD_STORE_ENOMEM; + goto out; + } + *value = gf_strdup(iter_val); + if (!*value) { + ret = -1; + store_errno = GD_STORE_ENOMEM; + goto out; + } + ret = 0; out: - GF_FREE (scan_str); - if (ret) { - GF_FREE (*key); - GF_FREE (*value); - *key = NULL; - *value = NULL; - } - if (op_errno) - *op_errno = store_errno; - - gf_msg_debug ("", 0, "Returning with %d", ret); - return ret; + GF_FREE(scan_str); + if (ret) { + GF_FREE(*key); + GF_FREE(*value); + *key = NULL; + *value = NULL; + } + if (op_errno) + *op_errno = store_errno; + + gf_msg_debug("", 0, "Returning with %d", ret); + return ret; } int32_t -gf_store_iter_get_matching (gf_store_iter_t *iter, char *key, char **value) +gf_store_iter_get_matching(gf_store_iter_t *iter, char *key, char **value) { - int32_t ret = -1; - char *tmp_key = NULL; - char *tmp_value = NULL; - - ret = gf_store_iter_get_next (iter, &tmp_key, &tmp_value, NULL); - while (!ret) { - if (!strncmp (key, tmp_key, strlen (key))){ - *value = tmp_value; - GF_FREE (tmp_key); - goto out; - } - GF_FREE (tmp_key); - tmp_key = NULL; - GF_FREE (tmp_value); - tmp_value = NULL; - ret = gf_store_iter_get_next (iter, &tmp_key, &tmp_value, - NULL); - } + int32_t ret = -1; + char *tmp_key = NULL; + char *tmp_value = NULL; + + ret = gf_store_iter_get_next(iter, &tmp_key, &tmp_value, NULL); + while (!ret) { + if (!strncmp(key, tmp_key, strlen(key))) { + *value = tmp_value; + GF_FREE(tmp_key); + goto out; + } + GF_FREE(tmp_key); + tmp_key = NULL; + GF_FREE(tmp_value); + tmp_value = NULL; + ret = gf_store_iter_get_next(iter, &tmp_key, &tmp_value, NULL); + } out: - return ret; + return ret; } int32_t -gf_store_iter_destroy (gf_store_iter_t *iter) +gf_store_iter_destroy(gf_store_iter_t *iter) { - int32_t ret = -1; - - if (!iter) - return 0; - - /* gf_store_iter_new will not return a valid iter object with iter->file - * being NULL*/ - ret = fclose (iter->file); - if (ret) - gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, "Unable" - " to close file: %s, ret: %d" , - iter->filepath, ret); - - GF_FREE (iter); - return ret; + int32_t ret = -1; + + if (!iter) + return 0; + + /* gf_store_iter_new will not return a valid iter object with iter->file + * being NULL*/ + ret = fclose(iter->file); + if (ret) + gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, + "Unable" + " to close file: %s, ret: %d", + iter->filepath, ret); + + GF_FREE(iter); + return ret; } -char* -gf_store_strerror (gf_store_op_errno_t op_errno) +char * +gf_store_strerror(gf_store_op_errno_t op_errno) { - switch (op_errno) { + switch (op_errno) { case GD_STORE_SUCCESS: - return "Success"; + return "Success"; case GD_STORE_KEY_NULL: - return "Invalid Key"; + return "Invalid Key"; case GD_STORE_VALUE_NULL: - return "Invalid Value"; + return "Invalid Value"; case GD_STORE_KEY_VALUE_NULL: - return "Invalid Key and Value"; + return "Invalid Key and Value"; case GD_STORE_EOF: - return "No data"; + return "No data"; case GD_STORE_ENOMEM: - return "No memory"; + return "No memory"; default: - return "Invalid errno"; - } + return "Invalid errno"; + } } int -gf_store_lock (gf_store_handle_t *sh) +gf_store_lock(gf_store_handle_t *sh) { - int ret; - - GF_ASSERT (sh); - GF_ASSERT (sh->path); - GF_ASSERT (sh->locked == F_ULOCK); - - sh->fd = open (sh->path, O_RDWR); - if (sh->fd == -1) { - gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, - "Failed to open '%s'", sh->path); - return -1; - } - - ret = lockf (sh->fd, F_LOCK, 0); - if (ret) - gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_LOCK_FAILED, - "Failed to gain lock on '%s'", sh->path); - else - /* sh->locked is protected by the lockf(sh->fd) above */ - sh->locked = F_LOCK; - - return ret; + int ret; + + GF_ASSERT(sh); + GF_ASSERT(sh->path); + GF_ASSERT(sh->locked == F_ULOCK); + + sh->fd = open(sh->path, O_RDWR); + if (sh->fd == -1) { + gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, + "Failed to open '%s'", sh->path); + return -1; + } + + ret = lockf(sh->fd, F_LOCK, 0); + if (ret) + gf_msg("", GF_LOG_ERROR, errno, LG_MSG_LOCK_FAILED, + "Failed to gain lock on '%s'", sh->path); + else + /* sh->locked is protected by the lockf(sh->fd) above */ + sh->locked = F_LOCK; + + return ret; } void -gf_store_unlock (gf_store_handle_t *sh) +gf_store_unlock(gf_store_handle_t *sh) { - GF_ASSERT (sh); - GF_ASSERT (sh->locked == F_LOCK); + GF_ASSERT(sh); + GF_ASSERT(sh->locked == F_LOCK); - sh->locked = F_ULOCK; + sh->locked = F_ULOCK; - /* does not matter if this fails, locks are released on close anyway */ - if (lockf (sh->fd, F_ULOCK, 0) == -1) - gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_UNLOCK_FAILED, - "Failed to release lock on '%s'", sh->path); + /* does not matter if this fails, locks are released on close anyway */ + if (lockf(sh->fd, F_ULOCK, 0) == -1) + gf_msg("", GF_LOG_ERROR, errno, LG_MSG_UNLOCK_FAILED, + "Failed to release lock on '%s'", sh->path); - sys_close (sh->fd); + sys_close(sh->fd); } int -gf_store_locked_local (gf_store_handle_t *sh) +gf_store_locked_local(gf_store_handle_t *sh) { - GF_ASSERT (sh); + GF_ASSERT(sh); - return (sh->locked == F_LOCK); + return (sh->locked == F_LOCK); } |