From 9c378026e9561595586a817fee0b439e2c863a22 Mon Sep 17 00:00:00 2001 From: Anuradha Talur Date: Mon, 23 Nov 2015 15:56:28 +0530 Subject: heal : Changed heal info to process all indices directories Change-Id: Ida863844e14309b6526c1b8434273fbf05c410d2 BUG: 1250803 Signed-off-by: Anuradha Talur Reviewed-on: http://review.gluster.org/12658 Tested-by: NetBSD Build System Tested-by: Gluster Build System Reviewed-by: Vijay Bellur --- heal/src/glfs-heal.c | 343 +++++++++++++++++++++++++++++++++++---------------- 1 file changed, 237 insertions(+), 106 deletions(-) (limited to 'heal') diff --git a/heal/src/glfs-heal.c b/heal/src/glfs-heal.c index 2f120c9bd3d..ce9ffbbc70b 100644 --- a/heal/src/glfs-heal.c +++ b/heal/src/glfs-heal.c @@ -26,7 +26,8 @@ "source-brick [] | "\ "split-brain-info]\n" -typedef void (*print_status) (dict_t *, char *, uuid_t, uint64_t *); +typedef void (*print_status) (dict_t *, char *, uuid_t, uint64_t *, + gf_boolean_t flag); int glfsh_heal_splitbrain_file (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc, char *file, dict_t *xattr_req); @@ -49,9 +50,30 @@ out: } +void +glfsh_print_heal_op_status (int ret, uint64_t num_entries, + gf_xl_afr_op_t heal_op) +{ + + if (ret < 0) { + printf ("Failed to process entries completely. " + "Number of entries so far: %"PRIu64"\n", num_entries); + } else { + if (heal_op == GF_SHD_OP_INDEX_SUMMARY) + printf ("Number of entries: %"PRIu64"\n", num_entries); + else if (heal_op == GF_SHD_OP_SPLIT_BRAIN_FILES) + printf ("Number of entries in split-brain: %"PRIu64"\n" + , num_entries); + else if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) + printf ("Number of healed entries: %"PRIu64"\n", + num_entries); + } + return; +} + int glfsh_get_index_dir_loc (loc_t *rootloc, xlator_t *xl, loc_t *dirloc, - int32_t *op_errno) + int32_t *op_errno, char *vgfid) { void *index_gfid = NULL; int ret = 0; @@ -59,14 +81,13 @@ glfsh_get_index_dir_loc (loc_t *rootloc, xlator_t *xl, loc_t *dirloc, struct iatt iattr = {0}; struct iatt parent = {0}; - ret = syncop_getxattr (xl, rootloc, &xattr, GF_XATTROP_INDEX_GFID, - NULL, NULL); + ret = syncop_getxattr (xl, rootloc, &xattr, vgfid, NULL, NULL); if (ret < 0) { *op_errno = -ret; goto out; } - ret = dict_get_ptr (xattr, GF_XATTROP_INDEX_GFID, &index_gfid); + ret = dict_get_ptr (xattr, vgfid, &index_gfid); if (ret < 0) { *op_errno = EINVAL; goto out; @@ -137,53 +158,105 @@ glfsh_index_purge (xlator_t *subvol, inode_t *inode, char *name) void glfsh_print_spb_status (dict_t *dict, char *path, uuid_t gfid, - uint64_t *num_entries) + uint64_t *num_entries, gf_boolean_t flag) { - char *value = NULL; - int ret = 0; + int ret = 0; + gf_boolean_t pending = _gf_false; + gf_boolean_t split_b = _gf_false; + char *value = NULL; - ret = dict_get_str (dict, "heal-info", &value); - if (ret) - return; + ret = dict_get_str (dict, "heal-info", &value); + if (ret) + return; - if (!strcmp (value, "split-brain")) { - (*num_entries)++; - printf ("%s\n", + if (!strcmp (value, "split-brain")) { + split_b = _gf_true; + } else if (!strcmp (value, "split-brain-pending")) { + split_b = _gf_true; + pending = _gf_true; + } + /* Consider the entry only iff : + * 1) The dir being processed is not indices/dirty, indicated by + * flag == _gf_false + * 2) The dir being processed is indices/dirty but the entry also + * exists in indices/xattrop dir and has already been processed. + */ + if (split_b) { + if (!flag || (flag && !pending)) { + (*num_entries)++; + printf ("%s\n", path ? path : uuid_utoa (gfid)); - } - return; + } + } + return; } void glfsh_print_heal_status (dict_t *dict, char *path, uuid_t gfid, - uint64_t *num_entries) + uint64_t *num_entries, gf_boolean_t ignore_dirty) { - char *value = NULL; - int ret = 0; - char *status = NULL; - - ret = dict_get_str (dict, "heal-info", &value); - if (ret || (!strcmp (value, "no-heal"))) - return; - - (*num_entries)++; - if (!strcmp (value, "heal")) { - ret = gf_asprintf (&status, " "); - } else if (!strcmp (value, "possibly-healing")) { - ret = gf_asprintf (&status, " - Possibly undergoing heal\n"); - } else if (!strcmp (value, "split-brain")) { - ret = gf_asprintf (&status, " - Is in split-brain\n"); - } - if (ret == -1) - status = NULL; - - printf ("%s%s\n", - path ? path : uuid_utoa (gfid), - status); - - if (status) - GF_FREE (status); - return; + int ret = 0; + gf_boolean_t pending = _gf_false; + char *status = NULL; + char *value = NULL; + + ret = dict_get_str (dict, "heal-info", &value); + if (ret || (!strcmp (value, "no-heal"))) + return; + + if (!strcmp (value, "heal")) { + ret = gf_asprintf (&status, " "); + if (ret < 0) + goto out; + } else if (!strcmp (value, "possibly-healing")) { + ret = gf_asprintf (&status, + " - Possibly undergoing heal\n"); + if (ret < 0) + goto out; + } else if (!strcmp (value, "split-brain")) { + ret = gf_asprintf (&status, " - Is in split-brain\n"); + if (ret < 0) + goto out; + } else if (!strcmp (value, "heal-pending")) { + pending = _gf_true; + ret = gf_asprintf (&status, " "); + if (ret < 0) + goto out; + } else if (!strcmp (value, "split-brain-pending")) { + pending = _gf_true; + ret = gf_asprintf (&status, " - Is in split-brain\n"); + if (ret < 0) + goto out; + } else if (!strcmp (value, "possibly-healing-pending")) { + pending = _gf_true; + ret = gf_asprintf (&status, + " - Possibly undergoing heal\n"); + if (ret < 0) + goto out; + } +out: + /* If ignore_dirty is set, it means indices/dirty directory is + * being processed. Ignore the entry if it also exists in + * indices/xattrop. + * Boolean pending is set to true if the entry also exists in + * indices/xattrop directory. + */ + if (ignore_dirty) { + if (pending) { + GF_FREE (status); + status = NULL; + return; + } + } + if (ret == -1) + status = NULL; + + (*num_entries)++; + printf ("%s%s\n", + path ? path : uuid_utoa (gfid), status ? status : ""); + + GF_FREE (status); + return; } static int @@ -216,7 +289,8 @@ glfsh_heal_entries (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc, static int glfsh_process_entries (xlator_t *xl, fd_t *fd, gf_dirent_t *entries, uint64_t *offset, uint64_t *num_entries, - print_status glfsh_print_status) + print_status glfsh_print_status, + gf_boolean_t ignore_dirty) { gf_dirent_t *entry = NULL; gf_dirent_t *tmp = NULL; @@ -258,7 +332,7 @@ glfsh_process_entries (xlator_t *xl, fd_t *fd, gf_dirent_t *entries, } if (dict) glfsh_print_status (dict, path, gfid, - num_entries); + num_entries, ignore_dirty); } ret = 0; GF_FREE (path); @@ -272,13 +346,13 @@ glfsh_process_entries (xlator_t *xl, fd_t *fd, gf_dirent_t *entries, static int glfsh_crawl_directory (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc, xlator_t *readdir_xl, fd_t *fd, loc_t *loc, - dict_t *xattr_req) + dict_t *xattr_req, uint64_t *num_entries, + gf_boolean_t ignore) { uint64_t offset = 0; gf_dirent_t entries; int ret = 0; gf_boolean_t free_entries = _gf_false; - uint64_t num_entries = 0; int heal_op = -1; INIT_LIST_HEAD (&entries.list); @@ -300,21 +374,23 @@ glfsh_crawl_directory (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc, if (heal_op == GF_SHD_OP_INDEX_SUMMARY) { ret = glfsh_process_entries (readdir_xl, fd, &entries, &offset, - &num_entries, - glfsh_print_heal_status); + num_entries, + glfsh_print_heal_status, + ignore); if (ret < 0) goto out; } else if (heal_op == GF_SHD_OP_SPLIT_BRAIN_FILES) { ret = glfsh_process_entries (readdir_xl, fd, &entries, &offset, - &num_entries, - glfsh_print_spb_status); + num_entries, + glfsh_print_spb_status, + ignore); if (ret < 0) goto out; } else if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) { ret = glfsh_heal_entries (fs, top_subvol, rootloc, &entries, &offset, - &num_entries, xattr_req); + num_entries, xattr_req); } gf_dirent_free (&entries); free_entries = _gf_false; @@ -323,19 +399,6 @@ glfsh_crawl_directory (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc, out: if (free_entries) gf_dirent_free (&entries); - if (ret < 0) { - printf ("Failed to complete gathering info. " - "Number of entries so far: %"PRIu64"\n", num_entries); - } else { - if (heal_op == GF_SHD_OP_INDEX_SUMMARY) - printf ("Number of entries: %"PRIu64"\n", num_entries); - else if (heal_op == GF_SHD_OP_SPLIT_BRAIN_FILES) - printf ("Number of entries in split-brain: %"PRIu64"\n" - , num_entries); - else if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) - printf ("Number of healed entries: %"PRIu64"\n", - num_entries); - } return ret; } @@ -361,14 +424,53 @@ out: return ret; } -void -glfsh_print_pending_heals (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc, - xlator_t *xl, gf_xl_afr_op_t heal_op) +int +glfsh_print_pending_heals_type (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc, + xlator_t *xl, gf_xl_afr_op_t heal_op, + dict_t *xattr_req, char *vgfid, + uint64_t *num_entries) { int ret = 0; loc_t dirloc = {0}; fd_t *fd = NULL; int32_t op_errno = 0; + gf_boolean_t ignore = _gf_false; + + if (!strcmp(vgfid, GF_XATTROP_DIRTY_GFID)) + ignore = _gf_true; + + ret = glfsh_get_index_dir_loc (rootloc, xl, &dirloc, &op_errno, + vgfid); + if (ret < 0) { + if (op_errno == ESTALE || op_errno == ENOENT) { + ret = 0; + } else { + printf ("Status: %s\n", strerror (op_errno)); + ret = -op_errno; + } + goto out; + } + + ret = syncop_dirfd (xl, &dirloc, &fd, GF_CLIENT_PID_GLFS_HEAL); + if (ret) + goto out; + + ret = glfsh_crawl_directory (fs, top_subvol, rootloc, xl, fd, &dirloc, + xattr_req, num_entries, ignore); + if (fd) + fd_unref (fd); +out: + loc_wipe (&dirloc); + return ret; +} + +void +glfsh_print_pending_heals (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc, + xlator_t *xl, gf_xl_afr_op_t heal_op) +{ + int ret = 0; + uint64_t count = 0, total = 0; + dict_t *xattr_req = NULL; xattr_req = dict_new(); @@ -378,38 +480,31 @@ glfsh_print_pending_heals (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc, ret = dict_set_int32 (xattr_req, "heal-op", heal_op); if (ret) goto out; + ret = glfsh_print_brick_from_xl (xl); if (ret < 0) goto out; - ret = glfsh_get_index_dir_loc (rootloc, xl, &dirloc, &op_errno); - if (ret < 0) { - if (op_errno == ESTALE || op_errno == ENOENT) - printf ("Number of entries: 0\n"); - else - printf ("Status: %s\n", strerror (op_errno)); - goto out; - } - - ret = syncop_dirfd (xl, &dirloc, &fd, GF_CLIENT_PID_GLFS_HEAL); - if (ret) + ret = glfsh_print_pending_heals_type (fs, top_subvol, rootloc, xl, + heal_op, xattr_req, + GF_XATTROP_INDEX_GFID, &count); + total += count; + count = 0; + if (ret == -ENOTCONN) goto out; - ret = glfsh_crawl_directory (fs, top_subvol, rootloc, xl, fd, &dirloc, - xattr_req); - if (fd) - fd_unref (fd); - if (xattr_req) - dict_unref (xattr_req); - if (ret < 0) { - if (heal_op == GF_SHD_OP_INDEX_SUMMARY) - printf ("Failed to find entries with pending" - " self-heal\n"); - if (heal_op == GF_SHD_OP_SPLIT_BRAIN_FILES) - printf ("Failed to find entries in split-brain\n"); + if (!strcmp (xl->type, "cluster/replicate")) { + ret = glfsh_print_pending_heals_type (fs, top_subvol, + rootloc, xl, + heal_op, xattr_req, + GF_XATTROP_DIRTY_GFID, + &count); + total += count; } out: - loc_wipe (&dirloc); + if (xattr_req) + dict_unref (xattr_req); + glfsh_print_heal_op_status (ret, total, heal_op); return; } @@ -597,16 +692,44 @@ out: return ret; } +int +glfsh_heal_from_brick_type (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc, + char *hostname, char *brickpath, xlator_t *client, + dict_t *xattr_req, char *vgfid, + uint64_t *num_entries) +{ + fd_t *fd = NULL; + loc_t dirloc = {0}; + int32_t op_errno = 0; + int ret = -1; + + ret = glfsh_get_index_dir_loc (rootloc, client, &dirloc, + &op_errno, vgfid); + if (ret < 0) + goto out; + + ret = syncop_dirfd (client, &dirloc, &fd, + GF_CLIENT_PID_GLFS_HEAL); + if (ret) + goto out; + ret = glfsh_crawl_directory (fs, top_subvol, rootloc, client, + fd, &dirloc, xattr_req, num_entries, + _gf_false); + if (fd) + fd_unref (fd); +out: + loc_wipe (&dirloc); + return ret; +} + int glfsh_heal_from_brick (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc, char *hostname, char *brickpath, char *file) { int ret = -1; + uint64_t count = 0, total = 0; dict_t *xattr_req = NULL; xlator_t *client = NULL; - fd_t *fd = NULL; - loc_t dirloc = {0}; - int32_t op_errno = 0; xattr_req = dict_new(); if (!xattr_req) @@ -627,23 +750,31 @@ glfsh_heal_from_brick (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc, goto out; if (file) ret = glfsh_heal_splitbrain_file (fs, top_subvol, rootloc, file, - xattr_req); + xattr_req); else { - ret = glfsh_get_index_dir_loc (rootloc, client, &dirloc, - &op_errno); - ret = syncop_dirfd (client, &dirloc, &fd, - GF_CLIENT_PID_GLFS_HEAL); - if (ret) + ret = glfsh_heal_from_brick_type (fs, top_subvol, rootloc, + hostname, brickpath, + client, xattr_req, + GF_XATTROP_INDEX_GFID, + &count); + total += count; + count = 0; + ret = glfsh_heal_from_brick_type (fs, top_subvol, rootloc, + hostname, brickpath, + client, xattr_req, + GF_XATTROP_DIRTY_GFID, + &count); + total += count; + if (ret < 0) goto out; - ret = glfsh_crawl_directory (fs, top_subvol, rootloc, client, - fd, &dirloc, xattr_req); - if (fd) - fd_unref (fd); } out: if (xattr_req) dict_unref (xattr_req); - loc_wipe (&dirloc); + if (!file) + glfsh_print_heal_op_status (ret, total, + GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK); + return ret; } -- cgit