andy/glusterfs
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

glusterd: Replace libglusterfs lists with liburcu lists

Browse Source 
This patch replaces usage of the libglusterfs lists data structures and
API in glusterd with the lists data structures and API from liburcu. The
liburcu data structes and APIs are a drop-in replacement for
libglusterfs lists.

All usages have been changed to keep the code consistent, and free from
confusion.

NOTE: glusterd_conf_t->xprt_list still uses the libglusterfs data
structures and API, as it holds rpc_transport_t objects, which is not a
part of glusterd and is not being changed in this patch.

This change was developed on the git branch at [1]. This commit is a
combination of the following commits on the development branch.
  6dac576 Replace libglusterfs lists with liburcu lists
  a51b5ab Fix compilation issues
  d98a06f Fix merge issues
  a5d918e Remove merge remnant
  1cca113 More style cleanup
  1917be3 Address review comments on 9624/1
  8d10f13 Use cds_lists for glusterd_svc_t
  524ad5d Add rculist header in glusterd-conn-helper.c
  646f294 glusterd: add list_add_order API honouring rcu

[1]: https://github.com/kshlm/glusterfs/tree/urcu

Change-Id: Ic613c5b6e496a677b9d3de15fc042a0492109fb0
BUG: 1191030
Signed-off-by: Kaushal M <kaushal@redhat.com>
Signed-off-by: Krishnan Parthasarathi <kparthas@redhat.com>
Reviewed-on: http://review.gluster.org/9624
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Atin Mukherjee <amukherj@redhat.com>
Reviewed-by: Gaurav Kumar Garg <ggarg@redhat.com>
Reviewed-by: Anand Nekkunti <anekkunt@redhat.com>
This commit is contained in:
Kaushal M 2015-01-06 18:23:41 +05:30 committed by Krishnan Parthasarathi
parent ef061b67f1
commit 673ba2659c
35 changed files with 631 additions and 540 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
xlators/mgmt/glusterd/src/glusterd-brick-ops.c
View File

@ -74,14 +74,14 @@ add_brick_at_right_order (glusterd_brickinfo_t *brickinfo,
insert_brick:
i = 0;
list_for_each_entry (brick, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brick, &volinfo->bricks, brick_list) {
i++;
if (i < idx)
continue;
gf_log (THIS->name, GF_LOG_DEBUG, "brick:%s index=%d, count=%d",
brick->path, idx, count);
list_add (&brickinfo->brick_list, &brick->brick_list);
cds_list_add (&brickinfo->brick_list, &brick->brick_list);
break;
}
@ -581,7 +581,7 @@ subvol_matcher_update (int *subvols, glusterd_volinfo_t *volinfo,
int32_t sub_volume = 0;
int pos = 0;
list_for_each_entry (tmp, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (tmp, &volinfo->bricks, brick_list) {
if (strcmp (tmp->hostname, brickinfo->hostname) ||
strcmp (tmp->path, brickinfo->path)) {
@ -1085,7 +1085,8 @@ glusterd_op_perform_add_bricks (glusterd_volinfo_t *volinfo, int32_t count,
add_brick_at_right_order (brickinfo, volinfo, (i - 1),
stripe_count, replica_count);
} else {
list_add_tail (&brickinfo->brick_list, &volinfo->bricks);
cds_list_add_tail (&brickinfo->brick_list,
&volinfo->bricks);
}
brick = strtok_r (NULL, " \n", &saveptr);
i++;
@ -1707,7 +1708,8 @@ glusterd_remove_brick_migrate_cbk (glusterd_volinfo_t *volinfo,
break;
case GF_DEFRAG_STATUS_STOPPED:
/* Fall back to the old volume file */
list_for_each_entry_safe (brickinfo, tmp, &volinfo->bricks, brick_list) {
cds_list_for_each_entry_safe (brickinfo, tmp, &volinfo->bricks,
brick_list) {
if (!brickinfo->decommissioned)
continue;
brickinfo->decommissioned = 0;
@ -1717,7 +1719,8 @@ glusterd_remove_brick_migrate_cbk (glusterd_volinfo_t *volinfo,
case GF_DEFRAG_STATUS_COMPLETE:
/* Done with the task, you can remove the brick from the
volume file */
list_for_each_entry_safe (brickinfo, tmp, &volinfo->bricks, brick_list) {
cds_list_for_each_entry_safe (brickinfo, tmp, &volinfo->bricks,
brick_list) {
if (!brickinfo->decommissioned)
continue;
gf_log (THIS->name, GF_LOG_INFO, "removing the brick %s",
@ -1909,8 +1912,8 @@ glusterd_op_remove_brick (dict_t *dict, char **op_errstr)
case GF_OP_CMD_STOP:
{
/* Fall back to the old volume file */
list_for_each_entry_safe (brickinfo, tmp, &volinfo->bricks,
brick_list) {
cds_list_for_each_entry_safe (brickinfo, tmp, &volinfo->bricks,
brick_list) {
if (!brickinfo->decommissioned)
continue;
brickinfo->decommissioned = 0;

5
xlators/mgmt/glusterd/src/glusterd-conn-helper.c
View File

@ -11,8 +11,11 @@
#include "glusterd-conn-mgmt.h"
#include "glusterd-svc-mgmt.h"
#define _LGPL_SOURCE
#include <urcu/rculist.h>
glusterd_svc_t *
glusterd_conn_get_svc_object (glusterd_conn_t *conn)
{
return list_entry (conn, glusterd_svc_t, conn);
return cds_list_entry (conn, glusterd_svc_t, conn);
}

4
xlators/mgmt/glusterd/src/glusterd-geo-rep.c
View File

@ -3640,7 +3640,7 @@ fetch_data:
if (ret)
gsync_count = 0;
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
if (uuid_compare (brickinfo->uuid, MY_UUID))
continue;
@ -4056,7 +4056,7 @@ glusterd_get_gsync_status_all (dict_t *rsp_dict, char *node)
GF_ASSERT (priv);
list_for_each_entry (volinfo, &priv->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &priv->volumes, vol_list) {
ret = glusterd_get_gsync_status_mst (volinfo, rsp_dict, node);
if (ret)
goto out;

45
xlators/mgmt/glusterd/src/glusterd-handler.c
View File

@ -465,7 +465,7 @@ glusterd_add_volume_detail_to_dict (glusterd_volinfo_t *volinfo,
}
#endif
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
char brick[1024] = {0,};
char brick_uuid[64] = {0,};
snprintf (key, 256, "volume%d.brick%d", count, i);
@ -609,7 +609,7 @@ glusterd_op_txn_begin (rpcsvc_request_t *req, glusterd_op_t op, void *ctx,
local_locking_done:
INIT_LIST_HEAD (&priv->xaction_peers);
CDS_INIT_LIST_HEAD (&priv->xaction_peers);
npeers = gd_build_peers_list (&priv->peers, &priv->xaction_peers, op);
@ -1162,8 +1162,8 @@ __glusterd_handle_cli_deprobe (rpcsvc_request_t *req)
* detached. It's not a problem if a volume contains none or all
* of its bricks on the peer being detached
*/
list_for_each_entry_safe (volinfo, tmp, &priv->volumes,
vol_list) {
cds_list_for_each_entry_safe (volinfo, tmp, &priv->volumes,
vol_list) {
ret = glusterd_friend_contains_vol_bricks (volinfo,
uuid);
if (ret == 1) {
@ -1379,7 +1379,7 @@ __glusterd_handle_cli_uuid_reset (rpcsvc_request_t *req)
*/
ret = -1;
// Do not allow peer reset if there are any volumes in the cluster
if (!list_empty (&priv->volumes)) {
if (!cds_list_empty (&priv->volumes)) {
snprintf (msg_str, sizeof (msg_str), "volumes are already "
"present in the cluster. Resetting uuid is not "
"allowed");
@ -1388,7 +1388,7 @@ __glusterd_handle_cli_uuid_reset (rpcsvc_request_t *req)
}
// Do not allow peer reset if trusted storage pool is already formed
if (!list_empty (&priv->peers)) {
if (!cds_list_empty (&priv->peers)) {
snprintf (msg_str, sizeof (msg_str),"trusted storage pool "
"has been already formed. Please detach this peer "
"from the pool and reset its uuid.");
@ -1550,7 +1550,7 @@ __glusterd_handle_cli_list_volume (rpcsvc_request_t *req)
if (!dict)
goto out;
list_for_each_entry (volinfo, &priv->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &priv->volumes, vol_list) {
memset (key, 0, sizeof (key));
snprintf (key, sizeof (key), "volume%d", count);
ret = dict_set_str (dict, key, volinfo->volname);
@ -2550,7 +2550,7 @@ __glusterd_handle_probe_query (rpcsvc_request_t *req)
goto out;
}
peerinfo = glusterd_peerinfo_find (probe_req.uuid, remote_hostname);
if ((peerinfo == NULL) && (!list_empty (&conf->peers))) {
if ((peerinfo == NULL) && (!cds_list_empty (&conf->peers))) {
rsp.op_ret = -1;
rsp.op_errno = GF_PROBE_ANOTHER_CLUSTER;
} else if (peerinfo == NULL) {
@ -3079,7 +3079,7 @@ glusterd_friend_add (const char *hoststr, int port,
* invalid peer name). That would mean we're adding something that had
* just been free, and we're likely to crash later.
*/
list_add_tail (&(*friend)->uuid_list, &conf->peers);
cds_list_add_tail (&(*friend)->uuid_list, &conf->peers);
//restore needs to first create the list of peers, then create rpcs
//to keep track of quorum in race-free manner. In restore for each peer
@ -3132,7 +3132,7 @@ glusterd_friend_add_from_peerinfo (glusterd_peerinfo_t *friend,
* invalid peer name). That would mean we're adding something that had
* just been free, and we're likely to crash later.
*/
list_add_tail (&friend->uuid_list, &conf->peers);
cds_list_add_tail (&friend->uuid_list, &conf->peers);
//restore needs to first create the list of peers, then create rpcs
//to keep track of quorum in race-free manner. In restore for each peer
@ -3590,8 +3590,8 @@ glusterd_list_friends (rpcsvc_request_t *req, dict_t *dict, int32_t flags)
gf_log ("", GF_LOG_WARNING, "Out of Memory");
goto out;
}
if (!list_empty (&priv->peers)) {
list_for_each_entry (entry, &priv->peers, uuid_list) {
if (!cds_list_empty (&priv->peers)) {
cds_list_for_each_entry (entry, &priv->peers, uuid_list) {
count++;
ret = gd_add_peer_detail_to_dict (entry,
friends, count);
@ -3665,13 +3665,13 @@ glusterd_get_volumes (rpcsvc_request_t *req, dict_t *dict, int32_t flags)
goto out;
}
if (list_empty (&priv->volumes)) {
if (cds_list_empty (&priv->volumes)) {
ret = 0;
goto respond;
}
if (flags == GF_CLI_GET_VOLUME_ALL) {
list_for_each_entry (entry, &priv->volumes, vol_list) {
cds_list_for_each_entry (entry, &priv->volumes, vol_list) {
ret = glusterd_add_volume_detail_to_dict (entry,
volumes, count);
if (ret)
@ -3686,17 +3686,17 @@ glusterd_get_volumes (rpcsvc_request_t *req, dict_t *dict, int32_t flags)
if (ret) {
if (priv->volumes.next) {
entry = list_entry (priv->volumes.next,
typeof (*entry),
vol_list);
entry = cds_list_entry (priv->volumes.next,
typeof (*entry),
vol_list);
}
} else {
ret = glusterd_volinfo_find (volname, &entry);
if (ret)
goto respond;
entry = list_entry (entry->vol_list.next,
typeof (*entry),
vol_list);
entry = cds_list_entry (entry->vol_list.next,
typeof (*entry),
vol_list);
}
if (&entry->vol_list == &priv->volumes) {
@ -4508,8 +4508,9 @@ __glusterd_peer_rpc_notify (struct rpc_clnt *rpc, void *mydata,
!uuid_compare (peerinfo->uuid, uuid))
glusterd_unlock (peerinfo->uuid);
} else {
list_for_each_entry (volinfo, &conf->volumes,
vol_list) {
cds_list_for_each_entry (volinfo,
&conf->volumes,
vol_list) {
ret = glusterd_mgmt_v3_unlock
(volinfo->volname,
peerinfo->uuid,

15
xlators/mgmt/glusterd/src/glusterd-handshake.c
View File

@ -446,7 +446,7 @@ glusterd_create_missed_snap (glusterd_missed_snap_info *missed_snapinfo,
}
/* Find the snap_vol */
list_for_each_entry (volinfo, &snap->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &snap->volumes, vol_list) {
if (!strcmp (volinfo->volname,
snap_opinfo->snap_vol_id)) {
snap_vol = volinfo;
@ -464,7 +464,7 @@ glusterd_create_missed_snap (glusterd_missed_snap_info *missed_snapinfo,
}
/* Find the missed brick in the snap volume */
list_for_each_entry (brickinfo, &snap_vol->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &snap_vol->bricks, brick_list) {
i++;
if (i == snap_opinfo->brick_num)
break;
@ -589,16 +589,17 @@ glusterd_take_missing_brick_snapshots (char *brick_name)
my_node_uuid = uuid_utoa (MY_UUID);
list_for_each_entry (missed_snapinfo, &priv->missed_snaps_list,
missed_snaps) {
cds_list_for_each_entry (missed_snapinfo, &priv->missed_snaps_list,
missed_snaps) {
/* If the missed snap op is not for the local node
* then continue
*/
if (strcmp (my_node_uuid, missed_snapinfo->node_uuid))
continue;
list_for_each_entry (snap_opinfo, &missed_snapinfo->snap_ops,
snap_ops_list) {
cds_list_for_each_entry (snap_opinfo,
&missed_snapinfo->snap_ops,
snap_ops_list) {
/* Check if the missed snap's op is a create for
* the brick name in question
*/
@ -936,7 +937,7 @@ gd_validate_cluster_op_version (xlator_t *this, int cluster_op_version,
* lead to inconsistencies in the cluster
*/
if ((cluster_op_version < conf->op_version) &&
!list_empty (&conf->volumes)) {
!cds_list_empty (&conf->volumes)) {
gf_log (this->name, GF_LOG_ERROR,
"cannot reduce operating version to %d from current "
"version %d as volumes exist (as per peer request from "

19
xlators/mgmt/glusterd/src/glusterd-hooks.c
View File

@ -213,8 +213,7 @@ glusterd_hooks_add_op_args (runner_t *runner, glusterd_op_t op,
int ret = -1;
priv = THIS->private;
list_for_each_entry (voliter, &priv->volumes,
vol_list) {
cds_list_for_each_entry (voliter, &priv->volumes, vol_list) {
if (glusterd_is_volume_started (voliter))
vol_count++;
}
@ -419,7 +418,7 @@ glusterd_hooks_post_stub_enqueue (char *scriptdir, glusterd_op_t op,
pthread_mutex_lock (&hooks_priv->mutex);
{
hooks_priv->waitcount++;
list_add_tail (&stub->all_hooks, &hooks_priv->list);
cds_list_add_tail (&stub->all_hooks, &hooks_priv->list);
pthread_cond_signal (&hooks_priv->cond);
}
pthread_mutex_unlock (&hooks_priv->mutex);
@ -445,7 +444,7 @@ glusterd_hooks_stub_init (glusterd_hooks_stub_t **stub, char *scriptdir,
if (!hooks_stub)
goto out;
INIT_LIST_HEAD (&hooks_stub->all_hooks);
CDS_INIT_LIST_HEAD (&hooks_stub->all_hooks);
hooks_stub->op = op;
hooks_stub->scriptdir = gf_strdup (scriptdir);
if (!hooks_stub->scriptdir)
@ -498,14 +497,14 @@ hooks_worker (void *args)
for (;;) {
pthread_mutex_lock (&hooks_priv->mutex);
{
while (list_empty (&hooks_priv->list)) {
while (cds_list_empty (&hooks_priv->list)) {
pthread_cond_wait (&hooks_priv->cond,
&hooks_priv->mutex);
}
stub = list_entry (hooks_priv->list.next,
glusterd_hooks_stub_t,
all_hooks);
list_del_init (&stub->all_hooks);
stub = cds_list_entry (hooks_priv->list.next,
glusterd_hooks_stub_t,
all_hooks);
cds_list_del_init (&stub->all_hooks);
hooks_priv->waitcount--;
}
@ -535,7 +534,7 @@ glusterd_hooks_priv_init (glusterd_hooks_private_t **new)
pthread_mutex_init (&hooks_priv->mutex, NULL);
pthread_cond_init (&hooks_priv->cond, NULL);
INIT_LIST_HEAD (&hooks_priv->list);
CDS_INIT_LIST_HEAD (&hooks_priv->list);
hooks_priv->waitcount = 0;
*new = hooks_priv;

4
xlators/mgmt/glusterd/src/glusterd-hooks.h
View File

@ -33,7 +33,7 @@ typedef enum glusterd_commit_hook_type {
} glusterd_commit_hook_type_t;
typedef struct hooks_private {
struct list_head list;
struct cds_list_head list;
int waitcount; //debug purposes
pthread_mutex_t mutex;
pthread_cond_t cond;
@ -41,7 +41,7 @@ typedef struct hooks_private {
} glusterd_hooks_private_t;
typedef struct hooks_stub {
struct list_head all_hooks;
struct cds_list_head all_hooks;
char *scriptdir;
glusterd_op_t op;
dict_t *op_ctx;

2
xlators/mgmt/glusterd/src/glusterd-log-ops.c
View File

@ -211,7 +211,7 @@ cont:
goto out;
ret = -1;
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
if (uuid_compare (brickinfo->uuid, MY_UUID))
continue;

20
xlators/mgmt/glusterd/src/glusterd-mgmt.c
View File

@ -385,7 +385,7 @@ int
glusterd_mgmt_v3_initiate_lockdown (glusterd_op_t op, dict_t *dict,
char **op_errstr, int npeers,
gf_boolean_t *is_acquired,
struct list_head *peers)
struct cds_list_head *peers)
{
char *volname = NULL;
glusterd_peerinfo_t *peerinfo = NULL;
@ -634,7 +634,7 @@ out:
int
glusterd_mgmt_v3_pre_validate (glusterd_op_t op, dict_t *req_dict,
char **op_errstr, int npeers,
struct list_head *peers)
struct cds_list_head *peers)
{
int32_t ret = -1;
int32_t peer_cnt = 0;
@ -867,7 +867,7 @@ out:
int
glusterd_mgmt_v3_brick_op (glusterd_op_t op, dict_t *req_dict,
char **op_errstr, int npeers,
struct list_head *peers)
struct cds_list_head *peers)
{
int32_t ret = -1;
int32_t peer_cnt = 0;
@ -1086,7 +1086,7 @@ out:
int
glusterd_mgmt_v3_commit (glusterd_op_t op, dict_t *op_ctx,
dict_t *req_dict, char **op_errstr,
int npeers, struct list_head *peers)
int npeers, struct cds_list_head *peers)
{
int32_t ret = -1;
int32_t peer_cnt = 0;
@ -1283,7 +1283,7 @@ out:
int
glusterd_mgmt_v3_post_validate (glusterd_op_t op, int32_t op_ret, dict_t *dict,
dict_t *req_dict, char **op_errstr, int npeers,
struct list_head *peers)
struct cds_list_head *peers)
{
int32_t ret = -1;
int32_t peer_cnt = 0;
@ -1472,7 +1472,7 @@ glusterd_mgmt_v3_release_peer_locks (glusterd_op_t op,
dict_t *dict, int32_t op_ret,
char **op_errstr, int npeers,
gf_boolean_t is_acquired,
struct list_head *peers)
struct cds_list_head *peers)
{
int32_t ret = -1;
int32_t peer_cnt = 0;
@ -1538,7 +1538,7 @@ glusterd_mgmt_v3_initiate_all_phases (rpcsvc_request_t *req, glusterd_op_t op,
xlator_t *this = NULL;
gf_boolean_t is_acquired = _gf_false;
uuid_t *originator_uuid = NULL;
struct list_head xaction_peers = {0,};
struct cds_list_head xaction_peers = {0,};
this = THIS;
GF_ASSERT (this);
@ -1547,7 +1547,7 @@ glusterd_mgmt_v3_initiate_all_phases (rpcsvc_request_t *req, glusterd_op_t op,
conf = this->private;
GF_ASSERT (conf);
INIT_LIST_HEAD (&xaction_peers);
CDS_INIT_LIST_HEAD (&xaction_peers);
npeers = gd_build_local_xaction_peers_list (&conf->peers,
&xaction_peers, op);
if (npeers == -1) {
@ -1758,7 +1758,7 @@ glusterd_mgmt_v3_initiate_snap_phases (rpcsvc_request_t *req, glusterd_op_t op,
uuid_t *originator_uuid = NULL;
gf_boolean_t success = _gf_false;
char *cli_errstr = NULL;
struct list_head xaction_peers = {0,};
struct cds_list_head xaction_peers = {0,};
this = THIS;
GF_ASSERT (this);
@ -1767,7 +1767,7 @@ glusterd_mgmt_v3_initiate_snap_phases (rpcsvc_request_t *req, glusterd_op_t op,
conf = this->private;
GF_ASSERT (conf);
INIT_LIST_HEAD (&xaction_peers);
CDS_INIT_LIST_HEAD (&xaction_peers);
npeers = gd_build_local_xaction_peers_list (&conf->peers,
&xaction_peers, op);
if (npeers == -1) {

4
xlators/mgmt/glusterd/src/glusterd-mountbroker.c
View File

@ -545,8 +545,8 @@ glusterd_do_mount (char *label, dict_t *argdict, char **path, int *op_errno)
}
/* look up spec for label */
list_for_each_entry (mspec, &priv->mount_specs,
speclist) {
cds_list_for_each_entry (mspec, &priv->mount_specs,
speclist) {
if (strcmp (mspec->label, label) != 0)
continue;
uid = evaluate_mount_request (mspec, argdict);

2
xlators/mgmt/glusterd/src/glusterd-mountbroker.h
View File

@ -24,7 +24,7 @@ struct gf_mount_pattern {
typedef struct gf_mount_pattern gf_mount_pattern_t;
struct gf_mount_spec {
struct list_head speclist;
struct cds_list_head speclist;
char *label;
gf_mount_pattern_t *patterns;
size_t len;

144
xlators/mgmt/glusterd/src/glusterd-op-sm.c
View File

@ -72,7 +72,7 @@
} \
} while (0)
static struct list_head gd_op_sm_queue;
static struct cds_list_head gd_op_sm_queue;
synclock_t gd_op_sm_lock;
glusterd_op_info_t opinfo = {{0},};
@ -954,8 +954,11 @@ glusterd_op_stage_set_volume (dict_t *dict, char **op_errstr)
ret = glusterd_validate_reconfopts (volinfo, val_dict, op_errstr);
else if (!all_vol) {
voliter = NULL;
list_for_each_entry (voliter, &priv->volumes, vol_list) {
ret = glusterd_validate_globalopts (voliter, val_dict, op_errstr);
cds_list_for_each_entry (voliter, &priv->volumes,
vol_list) {
ret = glusterd_validate_globalopts (voliter,
val_dict,
op_errstr);
if (ret)
break;
}
@ -1709,7 +1712,7 @@ glusterd_stop_bricks (glusterd_volinfo_t *volinfo)
{
glusterd_brickinfo_t *brickinfo = NULL;
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
/*TODO: Need to change @del_brick in brick_stop to _gf_true
* once we enable synctask in peer rpc prog */
if (glusterd_brick_stop (volinfo, brickinfo, _gf_false))
@ -1727,7 +1730,7 @@ glusterd_start_bricks (glusterd_volinfo_t *volinfo)
GF_ASSERT (volinfo);
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
ret = glusterd_brick_start (volinfo, brickinfo, _gf_false);
if (ret) {
gf_log (THIS->name, GF_LOG_ERROR,
@ -2006,12 +2009,14 @@ glusterd_op_set_volume (dict_t *dict)
quorum_action = _gf_true;
if (global_opt) {
list_for_each_entry (voliter, &priv->volumes, vol_list) {
value = gf_strdup (value);
ret = dict_set_dynstr (voliter->dict, key, value);
if (ret)
goto out;
}
cds_list_for_each_entry (voliter, &priv->volumes,
vol_list) {
value = gf_strdup (value);
ret = dict_set_dynstr (voliter->dict, key,
value);
if (ret)
goto out;
}
} else {
ret = dict_set_dynstr (volinfo->dict, key, value);
if (ret)
@ -2074,7 +2079,7 @@ glusterd_op_set_volume (dict_t *dict)
}
} else {
list_for_each_entry (voliter, &priv->volumes, vol_list) {
cds_list_for_each_entry (voliter, &priv->volumes, vol_list) {
volinfo = voliter;
gd_update_volume_op_versions (volinfo);
@ -2174,7 +2179,7 @@ glusterd_op_sync_volume (dict_t *dict, char **op_errstr,
1, "volume");
vol_count = 1;
} else {
list_for_each_entry (volinfo, &priv->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &priv->volumes, vol_list) {
ret = glusterd_add_volume_to_dict (volinfo, rsp_dict,
count, "volume");
if (ret)
@ -2674,7 +2679,8 @@ glusterd_op_status_volume (dict_t *dict, char **op_errstr,
goto out;
} else {
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
brick_index++;
if (uuid_compare (brickinfo->uuid, MY_UUID))
continue;
@ -2824,7 +2830,8 @@ glusterd_op_ac_send_lock (glusterd_op_sm_event_t *event, void *ctx)
priv = this->private;
GF_ASSERT (priv);
list_for_each_entry (peerinfo, &priv->xaction_peers, op_peers_list) {
cds_list_for_each_entry (peerinfo, &priv->xaction_peers,
op_peers_list) {
GF_ASSERT (peerinfo);
if (!peerinfo->connected || !peerinfo->mgmt)
@ -2913,7 +2920,8 @@ glusterd_op_ac_send_unlock (glusterd_op_sm_event_t *event, void *ctx)
priv = this->private;
GF_ASSERT (priv);
list_for_each_entry (peerinfo, &priv->xaction_peers, op_peers_list) {
cds_list_for_each_entry (peerinfo, &priv->xaction_peers,
op_peers_list) {
GF_ASSERT (peerinfo);
if (!peerinfo->connected || !peerinfo->mgmt ||
@ -3458,7 +3466,8 @@ glusterd_op_ac_send_stage_op (glusterd_op_sm_event_t *event, void *ctx)
if (op == GD_OP_REPLACE_BRICK)
glusterd_rb_use_rsp_dict (NULL, rsp_dict);
list_for_each_entry (peerinfo, &priv->xaction_peers, op_peers_list) {
cds_list_for_each_entry (peerinfo, &priv->xaction_peers,
op_peers_list) {
GF_ASSERT (peerinfo);
if (!peerinfo->connected || !peerinfo->mgmt)
@ -4108,7 +4117,8 @@ glusterd_op_ac_send_commit_op (glusterd_op_sm_event_t *event, void *ctx)
}
list_for_each_entry (peerinfo, &priv->xaction_peers, op_peers_list) {
cds_list_for_each_entry (peerinfo, &priv->xaction_peers,
op_peers_list) {
GF_ASSERT (peerinfo);
if (!peerinfo->connected || !peerinfo->mgmt)
@ -4958,7 +4968,7 @@ glusterd_op_commit_perform (glusterd_op_t op, dict_t *dict, char **op_errstr,
static int
glusterd_bricks_select_stop_volume (dict_t *dict, char **op_errstr,
struct list_head *selected)
struct cds_list_head *selected)
{
int ret = 0;
int flags = 0;
@ -4979,7 +4989,7 @@ glusterd_bricks_select_stop_volume (dict_t *dict, char **op_errstr,
goto out;
}
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
if (glusterd_is_brick_started (brickinfo)) {
pending_node = GF_CALLOC (1, sizeof (*pending_node),
gf_gld_mt_pending_node_t);
@ -4989,7 +4999,8 @@ glusterd_bricks_select_stop_volume (dict_t *dict, char **op_errstr,
} else {
pending_node->node = brickinfo;
pending_node->type = GD_NODE_BRICK;
list_add_tail (&pending_node->list, selected);
cds_list_add_tail (&pending_node->list,
selected);
pending_node = NULL;
}
}
@ -5001,7 +5012,7 @@ out:
static int
glusterd_bricks_select_remove_brick (dict_t *dict, char **op_errstr,
struct list_head *selected)
struct cds_list_head *selected)
{
int ret = -1;
char *volname = NULL;
@ -5064,7 +5075,8 @@ glusterd_bricks_select_remove_brick (dict_t *dict, char **op_errstr,
} else {
pending_node->node = brickinfo;
pending_node->type = GD_NODE_BRICK;
list_add_tail (&pending_node->list, selected);
cds_list_add_tail (&pending_node->list,
selected);
pending_node = NULL;
}
}
@ -5077,7 +5089,7 @@ out:
static int
glusterd_bricks_select_profile_volume (dict_t *dict, char **op_errstr,
struct list_head *selected)
struct cds_list_head *selected)
{
int ret = -1;
char *volname = NULL;
@ -5142,14 +5154,15 @@ glusterd_bricks_select_profile_volume (dict_t *dict, char **op_errstr,
}
pending_node->node = &(priv->nfs_svc);
pending_node->type = GD_NODE_NFS;
list_add_tail (&pending_node->list, selected);
cds_list_add_tail (&pending_node->list, selected);
pending_node = NULL;
ret = 0;
goto out;
}
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
if (glusterd_is_brick_started (brickinfo)) {
pending_node = GF_CALLOC (1, sizeof (*pending_node),
gf_gld_mt_pending_node_t);
@ -5159,8 +5172,8 @@ glusterd_bricks_select_profile_volume (dict_t *dict, char **op_errstr,
} else {
pending_node->node = brickinfo;
pending_node->type = GD_NODE_BRICK;
list_add_tail (&pending_node->list,
selected);
cds_list_add_tail (&pending_node->list,
selected);
pending_node = NULL;
}
}
@ -5184,7 +5197,7 @@ glusterd_bricks_select_profile_volume (dict_t *dict, char **op_errstr,
}
pending_node->node = &(priv->nfs_svc);
pending_node->type = GD_NODE_NFS;
list_add_tail (&pending_node->list, selected);
cds_list_add_tail (&pending_node->list, selected);
pending_node = NULL;
ret = 0;
@ -5209,14 +5222,15 @@ glusterd_bricks_select_profile_volume (dict_t *dict, char **op_errstr,
} else {
pending_node->node = brickinfo;
pending_node->type = GD_NODE_BRICK;
list_add_tail (&pending_node->list,
selected);
cds_list_add_tail (&pending_node->list,
selected);
pending_node = NULL;
goto out;
}
}
ret = 0;
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
if (glusterd_is_brick_started (brickinfo)) {
pending_node = GF_CALLOC (1, sizeof (*pending_node),
gf_gld_mt_pending_node_t);
@ -5226,8 +5240,8 @@ glusterd_bricks_select_profile_volume (dict_t *dict, char **op_errstr,
} else {
pending_node->node = brickinfo;
pending_node->type = GD_NODE_BRICK;
list_add_tail (&pending_node->list,
selected);
cds_list_add_tail (&pending_node->list,
selected);
pending_node = NULL;
}
}
@ -5297,7 +5311,7 @@ get_replica_index_for_per_replica_cmd (glusterd_volinfo_t *volinfo,
replica_count = volinfo->replica_count;
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
if (uuid_is_null (brickinfo->uuid))
(void)glusterd_resolve_brick (brickinfo);
if (!strcmp (brickinfo->path, path) &&
@ -5344,7 +5358,7 @@ _select_rxlators_with_local_bricks (xlator_t *this, glusterd_volinfo_t *volinfo,
index = 1;
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
if (uuid_is_null (brickinfo->uuid))
(void)glusterd_resolve_brick (brickinfo);
@ -5395,7 +5409,7 @@ _select_rxlators_for_full_self_heal (xlator_t *this,
priv = this->private;
replica_count = volinfo->replica_count;
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
if (uuid_is_null (brickinfo->uuid))
(void)glusterd_resolve_brick (brickinfo);
@ -5420,7 +5434,7 @@ _select_rxlators_for_full_self_heal (xlator_t *this,
static int
glusterd_bricks_select_snap (dict_t *dict, char **op_errstr,
struct list_head *selected)
struct cds_list_head *selected)
{
int ret = -1;
glusterd_conf_t *priv = NULL;
@ -5446,7 +5460,7 @@ glusterd_bricks_select_snap (dict_t *dict, char **op_errstr,
if (ret)
goto out;
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
brick_index++;
if (uuid_compare (brickinfo->uuid, MY_UUID) ||
!glusterd_is_brick_started (brickinfo)) {
@ -5461,8 +5475,7 @@ glusterd_bricks_select_snap (dict_t *dict, char **op_errstr,
pending_node->node = brickinfo;
pending_node->type = GD_NODE_BRICK;
pending_node->index = brick_index;
list_add_tail (&pending_node->list,
selected);
cds_list_add_tail (&pending_node->list, selected);
pending_node = NULL;
}
@ -5500,7 +5513,7 @@ fill_shd_status_for_local_bricks (dict_t *dict, glusterd_volinfo_t *volinfo,
}
}
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
if (uuid_is_null (brickinfo->uuid))
(void)glusterd_resolve_brick (brickinfo);
@ -5544,7 +5557,7 @@ out:
static int
glusterd_bricks_select_heal_volume (dict_t *dict, char **op_errstr,
struct list_head *selected,
struct cds_list_head *selected,
dict_t *rsp_dict)
{
int ret = -1;
@ -5670,7 +5683,7 @@ glusterd_bricks_select_heal_volume (dict_t *dict, char **op_errstr,
} else {
pending_node->node = &(priv->shd_svc);
pending_node->type = GD_NODE_SHD;
list_add_tail (&pending_node->list, selected);
cds_list_add_tail (&pending_node->list, selected);
pending_node = NULL;
}
@ -5682,7 +5695,7 @@ out:
static int
glusterd_bricks_select_rebalance_volume (dict_t *dict, char **op_errstr,
struct list_head *selected)
struct cds_list_head *selected)
{
int ret = -1;
char *volname = NULL;
@ -5717,8 +5730,7 @@ glusterd_bricks_select_rebalance_volume (dict_t *dict, char **op_errstr,
} else {
pending_node->node = volinfo;
pending_node->type = GD_NODE_REBALANCE;
list_add_tail (&pending_node->list,
&opinfo.pending_bricks);
cds_list_add_tail (&pending_node->list, &opinfo.pending_bricks);
pending_node = NULL;
}
@ -5728,7 +5740,7 @@ out:
static int
glusterd_bricks_select_status_volume (dict_t *dict, char **op_errstr,
struct list_head *selected)
struct cds_list_head *selected)
{
int ret = -1;
int cmd = 0;
@ -5808,7 +5820,7 @@ glusterd_bricks_select_status_volume (dict_t *dict, char **op_errstr,
pending_node->node = brickinfo;
pending_node->type = GD_NODE_BRICK;
pending_node->index = 0;
list_add_tail (&pending_node->list, selected);
cds_list_add_tail (&pending_node->list, selected);
ret = 0;
} else if ((cmd & GF_CLI_STATUS_NFS) != 0) {
@ -5827,7 +5839,7 @@ glusterd_bricks_select_status_volume (dict_t *dict, char **op_errstr,
pending_node->node = &(priv->nfs_svc);
pending_node->type = GD_NODE_NFS;
pending_node->index = 0;
list_add_tail (&pending_node->list, selected);
cds_list_add_tail (&pending_node->list, selected);
ret = 0;
} else if ((cmd & GF_CLI_STATUS_SHD) != 0) {
@ -5846,7 +5858,7 @@ glusterd_bricks_select_status_volume (dict_t *dict, char **op_errstr,
pending_node->node = &(priv->shd_svc);
pending_node->type = GD_NODE_SHD;
pending_node->index = 0;
list_add_tail (&pending_node->list, selected);
cds_list_add_tail (&pending_node->list, selected);
ret = 0;
} else if ((cmd & GF_CLI_STATUS_QUOTAD) != 0) {
@ -5865,7 +5877,7 @@ glusterd_bricks_select_status_volume (dict_t *dict, char **op_errstr,
pending_node->node = &(priv->quotad_svc);
pending_node->type = GD_NODE_QUOTAD;
pending_node->index = 0;
list_add_tail (&pending_node->list, selected);
cds_list_add_tail (&pending_node->list, selected);
ret = 0;
} else if ((cmd & GF_CLI_STATUS_SNAPD) != 0) {
@ -5887,11 +5899,12 @@ glusterd_bricks_select_status_volume (dict_t *dict, char **op_errstr,
pending_node->node = (void *)(&volinfo->snapd);
pending_node->type = GD_NODE_SNAPD;
pending_node->index = 0;
list_add_tail (&pending_node->list, selected);
cds_list_add_tail (&pending_node->list, selected);
ret = 0;
} else {
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
brick_index++;
if (uuid_compare (brickinfo->uuid, MY_UUID) ||
!glusterd_is_brick_started (brickinfo)) {
@ -5908,7 +5921,7 @@ glusterd_bricks_select_status_volume (dict_t *dict, char **op_errstr,
pending_node->node = brickinfo;
pending_node->type = GD_NODE_BRICK;
pending_node->index = brick_index;
list_add_tail (&pending_node->list, selected);
cds_list_add_tail (&pending_node->list, selected);
pending_node = NULL;
}
}
@ -5921,7 +5934,7 @@ out:
* and are running
*/
static int
glusterd_bricks_select_barrier (dict_t *dict, struct list_head *selected)
glusterd_bricks_select_barrier (dict_t *dict, struct cds_list_head *selected)
{
int ret = -1;
char *volname = NULL;
@ -5944,7 +5957,7 @@ glusterd_bricks_select_barrier (dict_t *dict, struct list_head *selected)
goto out;
}
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
if (uuid_compare (brickinfo->uuid, MY_UUID) ||
!glusterd_is_brick_started (brickinfo)) {
continue;
@ -5957,7 +5970,7 @@ glusterd_bricks_select_barrier (dict_t *dict, struct list_head *selected)
}
pending_node->node = brickinfo;
pending_node->type = GD_NODE_BRICK;
list_add_tail (&pending_node->list, selected);
cds_list_add_tail (&pending_node->list, selected);
pending_node = NULL;
}
@ -6079,7 +6092,7 @@ out:
int32_t
glusterd_op_bricks_select (glusterd_op_t op, dict_t *dict, char **op_errstr,
struct list_head *selected, dict_t *rsp_dict)
struct cds_list_head *selected, dict_t *rsp_dict)
{
int ret = 0;
@ -6439,7 +6452,7 @@ glusterd_op_sm_new_event (glusterd_op_sm_event_type_t event_type,
*new_event = event;
event->event = event_type;
INIT_LIST_HEAD (&event->list);
CDS_INIT_LIST_HEAD (&event->list);
return 0;
}
@ -6466,7 +6479,7 @@ glusterd_op_sm_inject_event (glusterd_op_sm_event_type_t event_type,
gf_log (THIS->name, GF_LOG_DEBUG, "Enqueue event: '%s'",
glusterd_op_sm_event_name_get (event->event));
list_add_tail (&event->list, &gd_op_sm_queue);
cds_list_add_tail (&event->list, &gd_op_sm_queue);
out:
return ret;
@ -6537,11 +6550,12 @@ glusterd_op_sm ()
goto lock_failed;
}
while (!list_empty (&gd_op_sm_queue)) {
while (!cds_list_empty (&gd_op_sm_queue)) {
list_for_each_entry_safe (event, tmp, &gd_op_sm_queue, list) {
cds_list_for_each_entry_safe (event, tmp, &gd_op_sm_queue,
list) {
list_del_init (&event->list);
cds_list_del_init (&event->list);
event_type = event->event;
gf_log (this->name, GF_LOG_DEBUG, "Dequeued event of "
"type: '%s'",
@ -6714,7 +6728,7 @@ glusterd_op_get_ctx ()
int
glusterd_op_sm_init ()
{
INIT_LIST_HEAD (&gd_op_sm_queue);
CDS_INIT_LIST_HEAD (&gd_op_sm_queue);
synclock_init (&gd_op_sm_lock);
return 0;
}

8
xlators/mgmt/glusterd/src/glusterd-op-sm.h
View File

@ -70,7 +70,7 @@ typedef enum glusterd_op_sm_event_type_ {
struct glusterd_op_sm_event_ {
struct list_head list;
struct cds_list_head list;
void *ctx;
glusterd_op_sm_event_type_t event;
uuid_t txn_id;
@ -96,13 +96,13 @@ struct glusterd_op_info_ {
int32_t brick_pending_count;
int32_t op_count;
glusterd_op_t op;
struct list_head op_peers;
struct cds_list_head op_peers;
void *op_ctx;
rpcsvc_request_t *req;
int32_t op_ret;
int32_t op_errno;
char *op_errstr;
struct list_head pending_bricks;
struct cds_list_head pending_bricks;
};
typedef struct glusterd_op_info_ glusterd_op_info_t;
@ -239,7 +239,7 @@ char*
glusterd_op_sm_event_name_get (int event);
int32_t
glusterd_op_bricks_select (glusterd_op_t op, dict_t *dict, char **op_errstr,
struct list_head *selected, dict_t *rsp_dict);
struct cds_list_head *selected, dict_t *rsp_dict);
int
glusterd_brick_op_build_payload (glusterd_op_t op, glusterd_brickinfo_t *brickinfo,
gd1_mgmt_brick_op_req **req, dict_t *dict);

51
xlators/mgmt/glusterd/src/glusterd-peer-utils.c
View File

@ -49,7 +49,7 @@ glusterd_peerinfo_destroy (glusterd_peerinfo_t *peerinfo)
if (!peerinfo)
goto out;
list_del_init (&peerinfo->uuid_list);
cds_list_del_init (&peerinfo->uuid_list);
ret = glusterd_store_delete_peerinfo (peerinfo);
if (ret) {
@ -59,8 +59,8 @@ glusterd_peerinfo_destroy (glusterd_peerinfo_t *peerinfo)
GF_FREE (peerinfo->hostname);
peerinfo->hostname = NULL;
list_for_each_entry_safe (hostname, tmp, &peerinfo->hostnames,
hostname_list) {
cds_list_for_each_entry_safe (hostname, tmp, &peerinfo->hostnames,
hostname_list) {
glusterd_peer_hostname_free (hostname);
}
@ -178,7 +178,7 @@ glusterd_peerinfo_find_by_uuid (uuid_t uuid)
if (uuid_is_null (uuid))
return NULL;
list_for_each_entry (entry, &priv->peers, uuid_list) {
cds_list_for_each_entry (entry, &priv->peers, uuid_list) {
if (!uuid_compare (entry->uuid, uuid)) {
gf_log (this->name, GF_LOG_DEBUG,
@ -252,11 +252,11 @@ glusterd_peerinfo_new (glusterd_friend_sm_state_t state, uuid_t *uuid,
if (!new_peer)
goto out;
INIT_LIST_HEAD (&new_peer->uuid_list);
CDS_INIT_LIST_HEAD (&new_peer->uuid_list);
new_peer->state.state = state;
INIT_LIST_HEAD (&new_peer->hostnames);
CDS_INIT_LIST_HEAD (&new_peer->hostnames);
if (hostname) {
ret = gd_add_address_to_peer (new_peer, hostname);
if (ret)
@ -303,7 +303,7 @@ glusterd_chk_peers_connected_befriended (uuid_t skip_uuid)
priv= THIS->private;
GF_ASSERT (priv);
list_for_each_entry (peerinfo, &priv->peers, uuid_list) {
cds_list_for_each_entry (peerinfo, &priv->peers, uuid_list) {
if (!uuid_is_null (skip_uuid) && !uuid_compare (skip_uuid,
peerinfo->uuid))
@ -336,8 +336,8 @@ glusterd_uuid_to_hostname (uuid_t uuid)
if (!uuid_compare (MY_UUID, uuid)) {
hostname = gf_strdup ("localhost");
}
if (!list_empty (&priv->peers)) {
list_for_each_entry (entry, &priv->peers, uuid_list) {
if (!cds_list_empty (&priv->peers)) {
cds_list_for_each_entry (entry, &priv->peers, uuid_list) {
if (!uuid_compare (entry->uuid, uuid)) {
hostname = gf_strdup (entry->hostname);
break;
@ -362,18 +362,18 @@ gd_peer_uuid_str (glusterd_peerinfo_t *peerinfo)
gf_boolean_t
glusterd_are_vol_all_peers_up (glusterd_volinfo_t *volinfo,
struct list_head *peers,
struct cds_list_head *peers,
char **down_peerstr)
{
glusterd_peerinfo_t *peerinfo = NULL;
glusterd_brickinfo_t *brickinfo = NULL;
gf_boolean_t ret = _gf_false;
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
if (!uuid_compare (brickinfo->uuid, MY_UUID))
continue;
list_for_each_entry (peerinfo, peers, uuid_list) {
cds_list_for_each_entry (peerinfo, peers, uuid_list) {
if (uuid_compare (peerinfo->uuid, brickinfo->uuid))
continue;
@ -413,7 +413,7 @@ glusterd_peer_hostname_new (const char *hostname,
goto out;
peer_hostname->hostname = gf_strdup (hostname);
INIT_LIST_HEAD (&peer_hostname->hostname_list);
CDS_INIT_LIST_HEAD (&peer_hostname->hostname_list);
*name = peer_hostname;
ret = 0;
@ -429,7 +429,7 @@ glusterd_peer_hostname_free (glusterd_peer_hostname_t *name)
if (!name)
return;
list_del_init (&name->hostname_list);
cds_list_del_init (&name->hostname_list);
GF_FREE (name->hostname);
name->hostname = NULL;
@ -448,7 +448,8 @@ gd_peer_has_address (glusterd_peerinfo_t *peerinfo, const char *address)
GF_VALIDATE_OR_GOTO ("glusterd", (peerinfo != NULL), out);
GF_VALIDATE_OR_GOTO ("glusterd", (address != NULL), out);
list_for_each_entry (hostname, &peerinfo->hostnames, hostname_list) {
cds_list_for_each_entry (hostname, &peerinfo->hostnames,
hostname_list) {
if (strcmp (hostname->hostname, address) == 0) {
ret = _gf_true;
break;
@ -478,7 +479,7 @@ gd_add_address_to_peer (glusterd_peerinfo_t *peerinfo, const char *address)
if (ret)
goto out;
list_add_tail (&hostname->hostname_list, &peerinfo->hostnames);
cds_list_add_tail (&hostname->hostname_list, &peerinfo->hostnames);
ret = 0;
out:
@ -525,8 +526,8 @@ gd_add_friend_to_dict (glusterd_peerinfo_t *friend, dict_t *dict,
*/
memset (key, 0, sizeof (key));
snprintf (key, sizeof (key), "%s.hostname", prefix);
address = list_entry (&friend->hostnames, glusterd_peer_hostname_t,
hostname_list);
address = cds_list_entry (&friend->hostnames, glusterd_peer_hostname_t,
hostname_list);
if (!address) {
ret = -1;
gf_log (this->name, GF_LOG_ERROR, "Could not retrieve first "
@ -547,7 +548,7 @@ gd_add_friend_to_dict (glusterd_peerinfo_t *friend, dict_t *dict,
address = NULL;
count = 0;
list_for_each_entry (address, &friend->hostnames, hostname_list) {
cds_list_for_each_entry (address, &friend->hostnames, hostname_list) {
GF_VALIDATE_OR_GOTO (this->name, (address != NULL), out);
memset (key, 0, sizeof (key));
@ -592,8 +593,9 @@ gd_peerinfo_find_from_hostname (const char *hoststr)
GF_VALIDATE_OR_GOTO (this->name, (hoststr != NULL), out);
list_for_each_entry (peer, &priv->peers, uuid_list) {
list_for_each_entry (tmphost, &peer->hostnames,hostname_list) {
cds_list_for_each_entry (peer, &priv->peers, uuid_list) {
cds_list_for_each_entry (tmphost, &peer->hostnames,
hostname_list) {
if (!strncasecmp (tmphost->hostname, hoststr, 1024)) {
gf_log (this->name, GF_LOG_DEBUG,
"Friend %s found.. state: %d",
@ -634,8 +636,9 @@ gd_peerinfo_find_from_addrinfo (const struct addrinfo *addr)
GF_VALIDATE_OR_GOTO (this->name, (addr != NULL), out);
list_for_each_entry (peer, &conf->peers, uuid_list) {
list_for_each_entry (address, &peer->hostnames, hostname_list) {
cds_list_for_each_entry (peer, &conf->peers, uuid_list) {
cds_list_for_each_entry (address, &peer->hostnames,
hostname_list) {
/* TODO: Cache the resolved addrinfos to improve
* performance
*/
@ -827,7 +830,7 @@ gd_add_peer_hostnames_to_dict (glusterd_peerinfo_t *peerinfo, dict_t *dict,
GF_VALIDATE_OR_GOTO (this->name, (dict != NULL), out);
GF_VALIDATE_OR_GOTO (this->name, (prefix != NULL), out);
list_for_each_entry (addr, &peerinfo->hostnames, hostname_list) {
cds_list_for_each_entry (addr, &peerinfo->hostnames, hostname_list) {
memset (key, 0, sizeof (key));
snprintf (key, sizeof (key), "%s.hostname%d", prefix, count);
ret = dict_set_dynstr_with_alloc (dict, key, addr->hostname);

3
xlators/mgmt/glusterd/src/glusterd-peer-utils.h
View File

@ -47,7 +47,8 @@ gd_peer_uuid_str (glusterd_peerinfo_t *peerinfo);
gf_boolean_t
glusterd_are_vol_all_peers_up (glusterd_volinfo_t *volinfo,
struct list_head *peers, char **down_peerstr);
struct cds_list_head *peers,
char **down_peerstr);
int32_t
glusterd_peer_hostname_new (const char *hostname,

2
xlators/mgmt/glusterd/src/glusterd-quota.c
View File

@ -1222,7 +1222,7 @@ glusterd_get_gfid_from_brick (dict_t *dict, glusterd_volinfo_t *volinfo,
goto out;
}
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
ret = glusterd_resolve_brick (brickinfo);
if (ret) {
gf_log (this->name, GF_LOG_ERROR, FMTSTR_RESOLVE_BRICK,

4
xlators/mgmt/glusterd/src/glusterd-rebalance.c
View File

@ -759,8 +759,8 @@ glusterd_op_rebalance (dict_t *dict, char **op_errstr, dict_t *rsp_dict)
volinfo->rebal.op = GD_OP_NONE;
/* Fall back to the old volume file in case of decommission*/
list_for_each_entry_safe (brickinfo, tmp, &volinfo->bricks,
brick_list) {
cds_list_for_each_entry_safe (brickinfo, tmp, &volinfo->bricks,
brick_list) {
if (!brickinfo->decommissioned)
continue;
brickinfo->decommissioned = 0;

4
xlators/mgmt/glusterd/src/glusterd-replace-brick.c
View File

@ -1556,8 +1556,8 @@ glusterd_op_perform_replace_brick (glusterd_volinfo_t *volinfo,
sizeof(new_brickinfo->mount_dir));
}
list_add_tail (&new_brickinfo->brick_list,
&old_brickinfo->brick_list);
cds_list_add_tail (&new_brickinfo->brick_list,
&old_brickinfo->brick_list);
volinfo->brick_count++;

4
xlators/mgmt/glusterd/src/glusterd-rpc-ops.c
View File

@ -2009,7 +2009,7 @@ glusterd_brick_op (call_frame_t *frame, xlator_t *this,
req_ctx = data;
GF_ASSERT (req_ctx);
INIT_LIST_HEAD (&opinfo.pending_bricks);
CDS_INIT_LIST_HEAD (&opinfo.pending_bricks);
ret = dict_get_bin (req_ctx->dict, "transaction_id", (void **)&txn_id);
gf_log (this->name, GF_LOG_DEBUG, "transaction ID = %s",
@ -2026,7 +2026,7 @@ glusterd_brick_op (call_frame_t *frame, xlator_t *this,
goto out;
}
list_for_each_entry (pending_node, &opinfo.pending_bricks, list) {
cds_list_for_each_entry (pending_node, &opinfo.pending_bricks, list) {
dummy_frame = create_frame (this, this->ctx->pool);
if (!dummy_frame)
continue;

27
xlators/mgmt/glusterd/src/glusterd-sm.c
View File

@ -37,7 +37,7 @@
#include "glusterd-store.h"
#include "glusterd-snapshot-utils.h"
static struct list_head gd_friend_sm_queue;
static struct cds_list_head gd_friend_sm_queue;
static char *glusterd_friend_sm_state_names[] = {
"Establishing Connection",
@ -156,7 +156,7 @@ glusterd_broadcast_friend_delete (char *hostname, uuid_t uuid)
if (ret)
goto out;
list_for_each_entry (peerinfo, &priv->peers, uuid_list) {
cds_list_for_each_entry (peerinfo, &priv->peers, uuid_list) {
if (!peerinfo->connected || !peerinfo->peer)
continue;
@ -479,7 +479,7 @@ glusterd_ac_send_friend_update (glusterd_friend_sm_event_t *event, void *ctx)
if (ret)
goto out;
list_for_each_entry (peerinfo, &priv->peers, uuid_list) {
cds_list_for_each_entry (peerinfo, &priv->peers, uuid_list) {
if (!glusterd_should_update_peer (peerinfo, cur_peerinfo))
continue;
@ -496,7 +496,7 @@ glusterd_ac_send_friend_update (glusterd_friend_sm_event_t *event, void *ctx)
if (ret)
goto out;
list_for_each_entry (peerinfo, &priv->peers, uuid_list) {
cds_list_for_each_entry (peerinfo, &priv->peers, uuid_list) {
if (!peerinfo->connected || !peerinfo->peer)
continue;
@ -536,8 +536,8 @@ glusterd_peer_detach_cleanup (glusterd_conf_t *priv)
GF_ASSERT (priv);
list_for_each_entry_safe (volinfo,tmp_volinfo,
&priv->volumes, vol_list) {
cds_list_for_each_entry_safe (volinfo, tmp_volinfo, &priv->volumes,
vol_list) {
/* The peer detach checks make sure that, at this point in the
* detach process, there are only volumes contained completely
* within or completely outside the detached peer.
@ -583,7 +583,7 @@ glusterd_ac_handle_friend_remove_req (glusterd_friend_sm_event_t *event,
ret = glusterd_xfer_friend_remove_resp (ev_ctx->req, ev_ctx->hostname,
ev_ctx->port);
list_for_each_entry (peerinfo, &priv->peers, uuid_list) {
cds_list_for_each_entry (peerinfo, &priv->peers, uuid_list) {
ret = glusterd_friend_sm_new_event (GD_FRIEND_EVENT_REMOVE_FRIEND,
&new_event);
@ -963,7 +963,7 @@ glusterd_friend_sm_new_event (glusterd_friend_sm_event_type_t event_type,
*new_event = event;
event->event = event_type;
INIT_LIST_HEAD (&event->list);
CDS_INIT_LIST_HEAD (&event->list);
return 0;
}
@ -974,7 +974,7 @@ glusterd_friend_sm_inject_event (glusterd_friend_sm_event_t *event)
GF_ASSERT (event);
gf_log ("glusterd", GF_LOG_DEBUG, "Enqueue event: '%s'",
glusterd_friend_sm_event_name_get (event->event));
list_add_tail (&event->list, &gd_friend_sm_queue);
cds_list_add_tail (&event->list, &gd_friend_sm_queue);
return 0;
}
@ -1043,10 +1043,11 @@ glusterd_friend_sm ()
priv = this->private;
GF_ASSERT (priv);
while (!list_empty (&gd_friend_sm_queue)) {
list_for_each_entry_safe (event, tmp, &gd_friend_sm_queue, list) {
while (!cds_list_empty (&gd_friend_sm_queue)) {
cds_list_for_each_entry_safe (event, tmp, &gd_friend_sm_queue,
list) {
list_del_init (&event->list);
cds_list_del_init (&event->list);
event_type = event->event;
peerinfo = event->peerinfo;
if (!peerinfo) {
@ -1152,6 +1153,6 @@ out:
int
glusterd_friend_sm_init ()
{
INIT_LIST_HEAD (&gd_friend_sm_queue);
CDS_INIT_LIST_HEAD (&gd_friend_sm_queue);
return 0;
}

14
xlators/mgmt/glusterd/src/glusterd-sm.h
View File

@ -29,6 +29,8 @@
#include "rpcsvc.h"
#include "store.h"
#include <urcu/rculist.h>
typedef enum gd_quorum_contribution_ {
QUORUM_NONE,
QUORUM_WAITING,
@ -58,7 +60,7 @@ typedef struct glusterd_peer_state_info_ {
typedef struct glusterd_peer_hostname_ {
char *hostname;
struct list_head hostname_list;
struct cds_list_head hostname_list;
} glusterd_peer_hostname_t;
typedef struct glusterd_sm_transition_ {
@ -84,10 +86,10 @@ struct glusterd_peerinfo_ {
*/
glusterd_peer_state_info_t state;
char *hostname;
struct list_head hostnames;
struct cds_list_head hostnames;
int port;
struct list_head uuid_list;
struct list_head op_peers_list;
struct cds_list_head uuid_list;
struct cds_list_head op_peers_list;
struct rpc_clnt *rpc;
rpc_clnt_prog_t *mgmt;
rpc_clnt_prog_t *peer;
@ -105,7 +107,7 @@ typedef struct glusterd_peerinfo_ glusterd_peerinfo_t;
typedef struct glusterd_local_peers_ {
glusterd_peerinfo_t *peerinfo;
struct list_head op_peers_list;
struct cds_list_head op_peers_list;
} glusterd_local_peers_t;
typedef enum glusterd_ev_gen_mode_ {
@ -151,7 +153,7 @@ typedef enum glusterd_friend_update_op_ {
struct glusterd_friend_sm_event_ {
struct list_head list;
struct cds_list_head list;
glusterd_peerinfo_t *peerinfo;
void *ctx;
glusterd_friend_sm_event_type_t event;

12
xlators/mgmt/glusterd/src/glusterd-snapd-svc.c
View File

@ -210,7 +210,7 @@ glusterd_snapdsvc_start (glusterd_svc_t *svc, int flags)
}
/* Get volinfo->snapd from svc object */
snapd = list_entry (svc, glusterd_snapdsvc_t, svc);
snapd = cds_list_entry (svc, glusterd_snapdsvc_t, svc);
if (!snapd) {
gf_log (this->name, GF_LOG_ERROR, "Failed to get snapd object "
"from snapd service");
@ -218,7 +218,7 @@ glusterd_snapdsvc_start (glusterd_svc_t *svc, int flags)
}
/* Get volinfo from snapd */
volinfo = list_entry (snapd, glusterd_volinfo_t, snapd);
volinfo = cds_list_entry (snapd, glusterd_volinfo_t, snapd);
if (!volinfo) {
gf_log (this->name, GF_LOG_ERROR, "Failed to get volinfo from "
"from snapd");
@ -318,7 +318,7 @@ glusterd_snapdsvc_restart ()
conf = this->private;
GF_ASSERT (conf);
list_for_each_entry (volinfo, &conf->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &conf->volumes, vol_list) {
/* Init per volume snapd svc */
ret = glusterd_snapdsvc_init (volinfo);
if (ret) {
@ -359,7 +359,7 @@ glusterd_snapdsvc_rpc_notify (glusterd_conn_t *conn, rpc_clnt_event_t event)
this = THIS;
GF_ASSERT (this);
svc = list_entry (conn, glusterd_svc_t, conn);
svc = cds_list_entry (conn, glusterd_svc_t, conn);
if (!svc) {
gf_log (this->name, GF_LOG_ERROR, "Failed to get the service");
return -1;
@ -382,14 +382,14 @@ glusterd_snapdsvc_rpc_notify (glusterd_conn_t *conn, rpc_clnt_event_t event)
break;
case RPC_CLNT_DESTROY:
snapd = list_entry (svc, glusterd_snapdsvc_t, svc);
snapd = cds_list_entry (svc, glusterd_snapdsvc_t, svc);
if (!snapd) {
gf_log (this->name, GF_LOG_ERROR, "Failed to get the "
"snapd object");
return -1;
}
volinfo = list_entry (snapd, glusterd_volinfo_t, snapd);
volinfo = cds_list_entry (snapd, glusterd_volinfo_t, snapd);
if (!volinfo) {
gf_log (this->name, GF_LOG_ERROR, "Failed to get the "
"volinfo object");

90
xlators/mgmt/glusterd/src/glusterd-snapshot-utils.c
View File

@ -121,7 +121,7 @@ glusterd_snap_volinfo_restore (dict_t *dict, dict_t *rsp_dict,
GF_VALIDATE_OR_GOTO (this->name, snap_volinfo, out);
brick_count = 0;
list_for_each_entry (brickinfo, &snap_volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &snap_volinfo->bricks, brick_list) {
brick_count++;
ret = glusterd_brickinfo_new (&new_brickinfo);
if (ret) {
@ -218,8 +218,8 @@ glusterd_snap_volinfo_restore (dict_t *dict, dict_t *rsp_dict,
}
}
list_add_tail (&new_brickinfo->brick_list,
&new_volinfo->bricks);
cds_list_add_tail (&new_brickinfo->brick_list,
&new_volinfo->bricks);
/* ownership of new_brickinfo is passed to new_volinfo */
new_brickinfo = NULL;
}
@ -268,8 +268,8 @@ glusterd_snap_volinfo_find_by_volume_id (uuid_t volume_id,
goto out;
}
list_for_each_entry (snap, &priv->snapshots, snap_list) {
list_for_each_entry (voliter, &snap->volumes, vol_list) {
cds_list_for_each_entry (snap, &priv->snapshots, snap_list) {
cds_list_for_each_entry (voliter, &snap->volumes, vol_list) {
if (uuid_compare (volume_id, voliter->volume_id))
continue;
*volinfo = voliter;
@ -299,7 +299,7 @@ glusterd_snap_volinfo_find (char *snap_volname, glusterd_snap_t *snap,
GF_ASSERT (snap);
GF_ASSERT (snap_volname);
list_for_each_entry (snap_vol, &snap->volumes, vol_list) {
cds_list_for_each_entry (snap_vol, &snap->volumes, vol_list) {
if (!strcmp (snap_vol->volname, snap_volname)) {
ret = 0;
*volinfo = snap_vol;
@ -330,7 +330,7 @@ glusterd_snap_volinfo_find_from_parent_volname (char *origin_volname,
GF_ASSERT (snap);
GF_ASSERT (origin_volname);
list_for_each_entry (snap_vol, &snap->volumes, vol_list) {
cds_list_for_each_entry (snap_vol, &snap->volumes, vol_list) {
if (!strcmp (snap_vol->parent_volname, origin_volname)) {
ret = 0;
*volinfo = snap_vol;
@ -514,11 +514,11 @@ glusterd_add_missed_snaps_to_export_dict (dict_t *peer_data)
GF_ASSERT (priv);
/* Add the missed_entries in the dict */
list_for_each_entry (missed_snapinfo, &priv->missed_snaps_list,
missed_snaps) {
list_for_each_entry (snap_opinfo,
&missed_snapinfo->snap_ops,
snap_ops_list) {
cds_list_for_each_entry (missed_snapinfo, &priv->missed_snaps_list,
missed_snaps) {
cds_list_for_each_entry (snap_opinfo,
&missed_snapinfo->snap_ops,
snap_ops_list) {
snprintf (name_buf, sizeof(name_buf),
"missed_snaps_%d", missed_snap_count);
snprintf (value, sizeof(value), "%s:%s=%s:%d:%s:%d:%d",
@ -575,7 +575,7 @@ glusterd_add_snap_to_dict (glusterd_snap_t *snap, dict_t *peer_data,
snprintf (prefix, sizeof(prefix), "snap%d", snap_count);
list_for_each_entry (volinfo, &snap->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &snap->volumes, vol_list) {
volcount++;
ret = glusterd_add_volume_to_dict (volinfo, peer_data,
volcount, prefix);
@ -603,7 +603,8 @@ glusterd_add_snap_to_dict (glusterd_snap_t *snap, dict_t *peer_data,
}
}
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
if (!uuid_compare (brickinfo->uuid, MY_UUID)) {
host_bricks = _gf_true;
break;
@ -706,7 +707,7 @@ glusterd_add_snapshots_to_export_dict (dict_t *peer_data)
GF_ASSERT (priv);
GF_ASSERT (peer_data);
list_for_each_entry (snap, &priv->snapshots, snap_list) {
cds_list_for_each_entry (snap, &priv->snapshots, snap_list) {
snap_count++;
ret = glusterd_add_snap_to_dict (snap, peer_data, snap_count);
if (ret) {
@ -905,8 +906,8 @@ glusterd_perform_missed_op (glusterd_snap_t *snap, int32_t op)
break;
case GF_SNAP_OPTION_TYPE_RESTORE:
list_for_each_entry_safe (snap_volinfo, tmp,
&snap->volumes, vol_list) {
cds_list_for_each_entry_safe (snap_volinfo, tmp, &snap->volumes,
vol_list) {
parent_volname = gf_strdup
(snap_volinfo->parent_volname);
if (!parent_volname)
@ -956,7 +957,7 @@ glusterd_perform_missed_op (glusterd_snap_t *snap, int32_t op)
/* Detach the volinfo from priv->volumes, so that no new
* command can ref it any more and then unref it.
*/
list_del_init (&volinfo->vol_list);
cds_list_del_init (&volinfo->vol_list);
glusterd_volinfo_unref (volinfo);
ret = glusterd_snapshot_restore_cleanup (dict,
@ -1014,8 +1015,8 @@ glusterd_perform_missed_snap_ops ()
priv = this->private;
GF_ASSERT (priv);
list_for_each_entry (missed_snapinfo, &priv->missed_snaps_list,
missed_snaps) {
cds_list_for_each_entry (missed_snapinfo, &priv->missed_snaps_list,
missed_snaps) {
/* If the pending snap_op is not for this node then continue */
if (strcmp (missed_snapinfo->node_uuid, uuid_utoa (MY_UUID)))
continue;
@ -1034,8 +1035,9 @@ glusterd_perform_missed_snap_ops ()
}
op_status = GD_MISSED_SNAP_PENDING;
list_for_each_entry (snap_opinfo, &missed_snapinfo->snap_ops,
snap_ops_list) {
cds_list_for_each_entry (snap_opinfo,
&missed_snapinfo->snap_ops,
snap_ops_list) {
/* If the snap_op is create or its status is
* GD_MISSED_SNAP_DONE then continue
*/
@ -1195,8 +1197,9 @@ glusterd_are_snap_bricks_local (glusterd_snap_t *snap)
GF_ASSERT (this);
GF_ASSERT (snap);
list_for_each_entry (volinfo, &snap->volumes, vol_list) {
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (volinfo, &snap->volumes, vol_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
if (!uuid_compare (brickinfo->uuid, MY_UUID)) {
is_local = _gf_true;
goto out;
@ -1232,8 +1235,8 @@ glusterd_peer_has_missed_snap_delete (glusterd_peerinfo_t *peerinfo,
peer_uuid = uuid_utoa (peerinfo->uuid);
list_for_each_entry (missed_snapinfo, &priv->missed_snaps_list,
missed_snaps) {
cds_list_for_each_entry (missed_snapinfo, &priv->missed_snaps_list,
missed_snaps) {
/* Look for missed snap for the same peer, and
* the same snap_id
*/
@ -1242,9 +1245,9 @@ glusterd_peer_has_missed_snap_delete (glusterd_peerinfo_t *peerinfo,
/* Check if the missed snap's op is delete and the
* status is pending
*/
list_for_each_entry (snap_opinfo,
&missed_snapinfo->snap_ops,
snap_ops_list) {
cds_list_for_each_entry (snap_opinfo,
&missed_snapinfo->snap_ops,
snap_ops_list) {
if (((snap_opinfo->op ==
GF_SNAP_OPTION_TYPE_DELETE) ||
(snap_opinfo->op ==
@ -1434,8 +1437,9 @@ glusterd_import_friend_snap (dict_t *peer_data, int32_t snap_count,
goto out;
}
list_add_order (&snap->snap_list, &priv->snapshots,
glusterd_compare_snap_time);
glusterd_list_add_order (&snap->snap_list, &priv->snapshots,
glusterd_compare_snap_time);
for (i = 1; i <= volcount; i++) {
ret = glusterd_import_volinfo (peer_data, i,
@ -2199,7 +2203,8 @@ out:
}
int
glusterd_compare_snap_time(struct list_head *list1, struct list_head *list2)
glusterd_compare_snap_time (struct cds_list_head *list1,
struct cds_list_head *list2)
{
glusterd_snap_t *snap1 = NULL;
glusterd_snap_t *snap2 = NULL;
@ -2208,15 +2213,16 @@ glusterd_compare_snap_time(struct list_head *list1, struct list_head *list2)
GF_ASSERT (list1);
GF_ASSERT (list2);
snap1 = list_entry(list1, glusterd_snap_t, snap_list);
snap2 = list_entry(list2, glusterd_snap_t, snap_list);
snap1 = cds_list_entry (list1, glusterd_snap_t, snap_list);
snap2 = cds_list_entry (list2, glusterd_snap_t, snap_list);
diff_time = difftime(snap1->time_stamp, snap2->time_stamp);
return (int)diff_time;
}
int
glusterd_compare_snap_vol_time(struct list_head *list1, struct list_head *list2)
glusterd_compare_snap_vol_time (struct cds_list_head *list1,
struct cds_list_head *list2)
{
glusterd_volinfo_t *snapvol1 = NULL;
glusterd_volinfo_t *snapvol2 = NULL;
@ -2225,8 +2231,8 @@ glusterd_compare_snap_vol_time(struct list_head *list1, struct list_head *list2)
GF_ASSERT (list1);
GF_ASSERT (list2);
snapvol1 = list_entry(list1, glusterd_volinfo_t, snapvol_list);
snapvol2 = list_entry(list2, glusterd_volinfo_t, snapvol_list);
snapvol1 = cds_list_entry (list1, glusterd_volinfo_t, snapvol_list);
snapvol2 = cds_list_entry (list2, glusterd_volinfo_t, snapvol_list);
diff_time = difftime(snapvol1->snapshot->time_stamp,
snapvol2->snapshot->time_stamp);
@ -2250,8 +2256,8 @@ glusterd_missed_snapinfo_new (glusterd_missed_snap_info **missed_snapinfo)
if (!new_missed_snapinfo)
goto out;
INIT_LIST_HEAD (&new_missed_snapinfo->missed_snaps);
INIT_LIST_HEAD (&new_missed_snapinfo->snap_ops);
CDS_INIT_LIST_HEAD (&new_missed_snapinfo->missed_snaps);
CDS_INIT_LIST_HEAD (&new_missed_snapinfo->snap_ops);
*missed_snapinfo = new_missed_snapinfo;
@ -2282,7 +2288,7 @@ glusterd_missed_snap_op_new (glusterd_snap_op_t **snap_op)
new_snap_op->brick_num = -1;
new_snap_op->op = -1;
new_snap_op->status = -1;
INIT_LIST_HEAD (&new_snap_op->snap_ops_list);
CDS_INIT_LIST_HEAD (&new_snap_op->snap_ops_list);
*snap_op = new_snap_op;
@ -2556,7 +2562,7 @@ out:
int32_t
glusterd_snap_quorum_check_for_create (dict_t *dict, gf_boolean_t snap_volume,
char **op_errstr,
struct list_head *peers_list)
struct cds_list_head *peers_list)
{
int8_t snap_force = 0;
int32_t force = 0;
@ -2745,7 +2751,7 @@ out:
int32_t
glusterd_snap_quorum_check (dict_t *dict, gf_boolean_t snap_volume,
char **op_errstr,
struct list_head *peers_list)
struct cds_list_head *peers_list)
{
int32_t ret = -1;
xlator_t *this = NULL;

8
xlators/mgmt/glusterd/src/glusterd-snapshot-utils.h
View File

@ -28,10 +28,10 @@ glusterd_add_snapd_to_dict (glusterd_volinfo_t *volinfo,
dict_t *dict, int32_t count);
int
glusterd_compare_snap_time(struct list_head *, struct list_head *);
glusterd_compare_snap_time (struct cds_list_head *, struct cds_list_head *);
int
glusterd_compare_snap_vol_time(struct list_head *, struct list_head *);
glusterd_compare_snap_vol_time (struct cds_list_head *, struct cds_list_head *);
int32_t
glusterd_snap_volinfo_restore (dict_t *dict, dict_t *rsp_dict,
@ -120,12 +120,12 @@ gd_import_volume_snap_details (dict_t *dict, glusterd_volinfo_t *volinfo,
int32_t
glusterd_snap_quorum_check (dict_t *dict, gf_boolean_t snap_volume,
char **op_errstr,
struct list_head *peers_list);
struct cds_list_head *peers_list);
int32_t
glusterd_snap_quorum_check_for_create (dict_t *dict, gf_boolean_t snap_volume,
char **op_errstr,
struct list_head *peers_list);
struct cds_list_head *peers_list);
int32_t
glusterd_snap_brick_create (glusterd_volinfo_t *snap_volinfo,

185
xlators/mgmt/glusterd/src/glusterd-snapshot.c
View File

@ -147,7 +147,7 @@ out:
/* Look for disconnected peers, for missed snap creates or deletes */
static int32_t
glusterd_find_missed_snap (dict_t *rsp_dict, glusterd_volinfo_t *vol,
struct list_head *peers, int32_t op)
struct cds_list_head *peers, int32_t op)
{
int32_t brick_count = -1;
int32_t ret = -1;
@ -162,14 +162,14 @@ glusterd_find_missed_snap (dict_t *rsp_dict, glusterd_volinfo_t *vol,
GF_ASSERT (vol);
brick_count = 0;
list_for_each_entry (brickinfo, &vol->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &vol->bricks, brick_list) {
if (!uuid_compare (brickinfo->uuid, MY_UUID)) {
/* If the brick belongs to the same node */
brick_count++;
continue;
}
list_for_each_entry (peerinfo, peers, uuid_list) {
cds_list_for_each_entry (peerinfo, peers, uuid_list) {
if (uuid_compare (peerinfo->uuid, brickinfo->uuid)) {
/* If the brick doesnt belong to this peer */
continue;
@ -244,7 +244,7 @@ snap_max_limits_display_commit (dict_t *rsp_dict, char *volname,
if (!volname) {
/* For system limit */
list_for_each_entry (volinfo, &conf->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &conf->volumes, vol_list) {
if (volinfo->is_snap_volume == _gf_true)
continue;
@ -764,7 +764,8 @@ glusterd_snapshot_restore (dict_t *dict, char **op_errstr, dict_t *rsp_dict)
}
volcount = 0;
list_for_each_entry_safe (snap_volinfo, tmp, &snap->volumes, vol_list) {
cds_list_for_each_entry_safe (snap_volinfo, tmp, &snap->volumes,
vol_list) {
volcount++;
ret = glusterd_volinfo_find (snap_volinfo->parent_volname,
&parent_volinfo);
@ -854,7 +855,7 @@ glusterd_snapshot_restore (dict_t *dict, char **op_errstr, dict_t *rsp_dict)
/* Detach the volinfo from priv->volumes, so that no new
* command can ref it any more and then unref it.
*/
list_del_init (&parent_volinfo->vol_list);
cds_list_del_init (&parent_volinfo->vol_list);
glusterd_volinfo_unref (parent_volinfo);
}
@ -985,10 +986,11 @@ glusterd_snapshot_restore_prevalidate (dict_t *dict, char **op_errstr,
/* Get brickinfo for snap_volumes */
volcount = 0;
list_for_each_entry (volinfo, &snap->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &snap->volumes, vol_list) {
volcount++;
brick_count = 0;
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
brick_count++;
if (uuid_compare (brickinfo->uuid, MY_UUID))
continue;
@ -1984,7 +1986,8 @@ glusterd_snapshot_create_prevalidate (dict_t *dict, char **op_errstr,
brick_count = 0;
brick_order = 0;
/* Adding snap bricks mount paths to the dict */
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
if (uuid_compare (brickinfo->uuid, MY_UUID)) {
brick_order++;
continue;
@ -2167,8 +2170,8 @@ glusterd_new_snap_object()
return NULL;
}
INIT_LIST_HEAD (&snap->snap_list);
INIT_LIST_HEAD (&snap->volumes);
CDS_INIT_LIST_HEAD (&snap->snap_list);
CDS_INIT_LIST_HEAD (&snap->volumes);
snap->snapname[0] = 0;
snap->snap_status = GD_SNAP_STATUS_INIT;
}
@ -2192,12 +2195,13 @@ glusterd_list_add_snapvol (glusterd_volinfo_t *origin_vol,
snap = snap_vol->snapshot;
GF_ASSERT (snap);
list_add_tail (&snap_vol->vol_list, &snap->volumes);
cds_list_add_tail (&snap_vol->vol_list, &snap->volumes);
LOCK (&origin_vol->lock);
{
list_add_order (&snap_vol->snapvol_list,
&origin_vol->snap_volumes,
glusterd_compare_snap_vol_time);
glusterd_list_add_order (&snap_vol->snapvol_list,
&origin_vol->snap_volumes,
glusterd_compare_snap_vol_time);
origin_vol->snap_count++;
}
UNLOCK (&origin_vol->lock);
@ -2219,7 +2223,7 @@ glusterd_find_snap_by_name (char *snapname)
GF_ASSERT (priv);
GF_ASSERT (snapname);
list_for_each_entry (snap, &priv->snapshots, snap_list) {
cds_list_for_each_entry (snap, &priv->snapshots, snap_list) {
if (!strcmp (snap->snapname, snapname)) {
gf_log (THIS->name, GF_LOG_DEBUG, "Found "
"snap %s (%s)", snap->snapname,
@ -2244,7 +2248,7 @@ glusterd_find_snap_by_id (uuid_t snap_id)
if (uuid_is_null(snap_id))
goto out;
list_for_each_entry (snap, &priv->snapshots, snap_list) {
cds_list_for_each_entry (snap, &priv->snapshots, snap_list) {
if (!uuid_compare (snap->snap_id, snap_id)) {
gf_log (THIS->name, GF_LOG_DEBUG, "Found "
"snap %s (%s)", snap->snapname,
@ -2391,7 +2395,7 @@ glusterd_lvm_snapshot_remove (dict_t *rsp_dict, glusterd_volinfo_t *snap_vol)
}
brick_count = -1;
list_for_each_entry (brickinfo, &snap_vol->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &snap_vol->bricks, brick_list) {
brick_count++;
if (uuid_compare (brickinfo->uuid, MY_UUID)) {
gf_log (this->name, GF_LOG_DEBUG,
@ -2568,7 +2572,7 @@ glusterd_snap_volume_remove (dict_t *rsp_dict,
goto out;
}
list_for_each_entry (brickinfo, &snap_vol->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &snap_vol->bricks, brick_list) {
if (uuid_compare (brickinfo->uuid, MY_UUID))
continue;
@ -2606,7 +2610,7 @@ glusterd_snap_volume_remove (dict_t *rsp_dict,
goto out;
}
if (!list_empty(&snap_vol->snapvol_list)) {
if (!cds_list_empty (&snap_vol->snapvol_list)) {
ret = glusterd_volinfo_find (snap_vol->parent_volname,
&origin_vol);
if (ret) {
@ -2644,8 +2648,8 @@ glusterd_snapobject_delete (glusterd_snap_t *snap)
return -1;
}
list_del_init (&snap->snap_list);
list_del_init (&snap->volumes);
cds_list_del_init (&snap->snap_list);
cds_list_del_init (&snap->volumes);
if (LOCK_DESTROY(&snap->lock))
gf_log (THIS->name, GF_LOG_WARNING, "Failed destroying lock"
"of snap %s", snap->snapname);
@ -2679,7 +2683,7 @@ glusterd_snap_remove (dict_t *rsp_dict,
goto out;
}
list_for_each_entry_safe (snap_vol, tmp, &snap->volumes, vol_list) {
cds_list_for_each_entry_safe (snap_vol, tmp, &snap->volumes, vol_list) {
ret = glusterd_snap_volume_remove (rsp_dict, snap_vol,
remove_lvm, force);
if (ret && !force) {
@ -2992,7 +2996,8 @@ glusterd_snapshot_get_snap_detail (dict_t *dict, glusterd_snap_t *snap,
goto done;
}
list_for_each_entry_safe (snap_vol, tmp_vol, &snap->volumes, vol_list) {
cds_list_for_each_entry_safe (snap_vol, tmp_vol, &snap->volumes,
vol_list) {
volcount++;
snprintf (key, sizeof (key), "%s.vol%d", keyprefix, volcount);
ret = glusterd_snapshot_get_snapvol_detail (dict,
@ -3040,7 +3045,8 @@ glusterd_snapshot_get_all_snap_info (dict_t *dict)
/* General parameter validation */
GF_ASSERT (dict);
list_for_each_entry_safe (snap, tmp_snap, &priv->snapshots, snap_list) {
cds_list_for_each_entry_safe (snap, tmp_snap, &priv->snapshots,
snap_list) {
snapcount++;
snprintf (key, sizeof (key), "snap%d", snapcount);
ret = glusterd_snapshot_get_snap_detail (dict, snap, key, NULL);
@ -3142,8 +3148,8 @@ glusterd_snapshot_get_info_by_volume (dict_t *dict, char *volname,
}
value = NULL;
list_for_each_entry_safe (snap_vol, tmp_vol, &volinfo->snap_volumes,
snapvol_list) {
cds_list_for_each_entry_safe (snap_vol, tmp_vol, &volinfo->snap_volumes,
snapvol_list) {
snapcount++;
snprintf (key, sizeof (key), "snap%d", snapcount);
ret = glusterd_snapshot_get_snap_detail (dict,
@ -3316,7 +3322,8 @@ glusterd_snapshot_get_all_snapnames (dict_t *dict)
GF_ASSERT (priv);
GF_ASSERT (dict);
list_for_each_entry_safe (snap, tmp_snap, &priv->snapshots, snap_list) {
cds_list_for_each_entry_safe (snap, tmp_snap, &priv->snapshots,
snap_list) {
snapcount++;
snapname = gf_strdup (snap->snapname);
if (!snapname) {
@ -3363,7 +3370,7 @@ glusterd_snapshot_get_vol_snapnames (dict_t *dict, glusterd_volinfo_t *volinfo)
GF_ASSERT (dict);
GF_ASSERT (volinfo);
list_for_each_entry_safe (snap_vol, tmp_vol,
cds_list_for_each_entry_safe (snap_vol, tmp_vol,
&volinfo->snap_volumes, snapvol_list) {
snapcount++;
snprintf (key, sizeof (key), "snapname%d", snapcount);
@ -3695,7 +3702,7 @@ glusterd_handle_snapshot_restore (rpcsvc_request_t *req, glusterd_op_t op,
goto out;
}
list_for_each_entry (snap_volinfo, &snap->volumes, vol_list) {
cds_list_for_each_entry (snap_volinfo, &snap->volumes, vol_list) {
i++;
snprintf (key, sizeof (key), "volname%d", i);
buf = gf_strdup (snap_volinfo->parent_volname);
@ -3780,7 +3787,7 @@ glusterd_create_snap_object (dict_t *dict, dict_t *rsp_dict)
goto out;
}
list_for_each_entry (snap, &priv->snapshots, snap_list) {
cds_list_for_each_entry (snap, &priv->snapshots, snap_list) {
if (!strcmp (snap->snapname, snapname) ||
!uuid_compare (snap->snap_id, *snap_id)) {
gf_log (THIS->name, GF_LOG_ERROR,
@ -3828,8 +3835,8 @@ glusterd_create_snap_object (dict_t *dict, dict_t *rsp_dict)
goto out;
}
list_add_order (&snap->snap_list, &priv->snapshots,
glusterd_compare_snap_time);
glusterd_list_add_order (&snap->snap_list, &priv->snapshots,
glusterd_compare_snap_time);
gf_log (this->name, GF_LOG_TRACE, "Snapshot %s added to the list",
snap->snapname);
@ -4221,7 +4228,7 @@ glusterd_add_brick_to_snap_volume (dict_t *dict, dict_t *rsp_dict,
/* AFR changelog names are based on brick_id and hence the snap
* volume's bricks must retain the same ID */
strcpy (snap_brickinfo->brick_id, original_brickinfo->brick_id);
list_add_tail (&snap_brickinfo->brick_list, &snap_vol->bricks);
cds_list_add_tail (&snap_brickinfo->brick_list, &snap_vol->bricks);
out:
if (ret && snap_brickinfo)
@ -4464,7 +4471,7 @@ glusterd_do_snap_vol (glusterd_volinfo_t *origin_vol, glusterd_snap_t *snap,
/* Adding snap brickinfos to the snap volinfo */
brick_count = 0;
list_for_each_entry (brickinfo, &origin_vol->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &origin_vol->bricks, brick_list) {
ret = glusterd_add_brick_to_snap_volume (dict, rsp_dict,
snap_vol, brickinfo,
volcount, brick_count);
@ -4602,8 +4609,8 @@ glusterd_snapshot_activate_deactivate_prevalidate (dict_t *dict,
/* TODO : As of now there is only volume in snapshot.
* Change this when multiple volume snapshot is introduced
*/
snap_volinfo = list_entry (snap->volumes.next, glusterd_volinfo_t,
vol_list);
snap_volinfo = cds_list_entry (snap->volumes.next, glusterd_volinfo_t,
vol_list);
if (!snap_volinfo) {
gf_log (this->name, GF_LOG_ERROR,
"Unable to fetch snap_volinfo");
@ -4710,7 +4717,8 @@ glusterd_handle_snapshot_delete_all (dict_t *dict)
GF_ASSERT (dict);
list_for_each_entry_safe (snap, tmp_snap, &priv->snapshots, snap_list) {
cds_list_for_each_entry_safe (snap, tmp_snap, &priv->snapshots,
snap_list) {
/* indexing from 1 to n, to keep it uniform with other code
* paths
*/
@ -4780,7 +4788,7 @@ glusterd_handle_snapshot_delete_type_snap (rpcsvc_request_t *req,
}
/* Set volnames in the dict to get mgmt_v3 lock */
list_for_each_entry_safe (snap_vol, tmp, &snap->volumes, vol_list) {
cds_list_for_each_entry_safe (snap_vol, tmp, &snap->volumes, vol_list) {
volcount++;
volname = gf_strdup (snap_vol->parent_volname);
if (!volname) {
@ -5086,8 +5094,8 @@ glusterd_snapshot_activate_commit (dict_t *dict, char **op_errstr,
/* TODO : As of now there is only volume in snapshot.
* Change this when multiple volume snapshot is introduced
*/
snap_volinfo = list_entry (snap->volumes.next, glusterd_volinfo_t,
vol_list);
snap_volinfo = cds_list_entry (snap->volumes.next, glusterd_volinfo_t,
vol_list);
if (!snap_volinfo) {
gf_log (this->name, GF_LOG_ERROR,
"Unable to fetch snap_volinfo");
@ -5157,8 +5165,8 @@ glusterd_snapshot_deactivate_commit (dict_t *dict, char **op_errstr,
/* TODO : As of now there is only volume in snapshot.
* Change this when multiple volume snapshot is introduced
*/
snap_volinfo = list_entry (snap->volumes.next, glusterd_volinfo_t,
vol_list);
snap_volinfo = cds_list_entry (snap->volumes.next, glusterd_volinfo_t,
vol_list);
if (!snap_volinfo) {
gf_log (this->name, GF_LOG_ERROR,
"Unable to fetch snap_volinfo");
@ -5254,9 +5262,9 @@ glusterd_snapshot_remove_commit (dict_t *dict, char **op_errstr,
/* TODO : As of now there is only volume in snapshot.
* Change this when multiple volume snapshot is introduced
*/
snap_volinfo = list_entry (snap->volumes.next,
glusterd_volinfo_t,
vol_list);
snap_volinfo = cds_list_entry (snap->volumes.next,
glusterd_volinfo_t,
vol_list);
if (!snap_volinfo) {
gf_log (this->name, GF_LOG_ERROR,
"Unable to fetch snap_volinfo");
@ -5482,11 +5490,12 @@ glusterd_schedule_brick_snapshot (dict_t *dict, dict_t *rsp_dict,
GF_ASSERT(snap);
synctask_barrier_init ((&args));
list_for_each_entry (snap_vol, &snap->volumes, vol_list) {
cds_list_for_each_entry (snap_vol, &snap->volumes, vol_list) {
volcount++;
brickcount = 0;
brickorder = 0;
list_for_each_entry (brickinfo, &snap_vol->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &snap_vol->bricks,
brick_list) {
snprintf (key, sizeof(key) - 1,
"snap-vol%d.brick%d.order", volcount,
brickcount);
@ -5698,7 +5707,7 @@ glusterd_snapshot_create_commit (dict_t *dict, char **op_errstr,
GLUSTERD_STORE_KEY_SNAP_ACTIVATE,
_gf_false);
if (!snap_activate) {
list_for_each_entry (snap_vol, &snap->volumes, vol_list) {
cds_list_for_each_entry (snap_vol, &snap->volumes, vol_list) {
snap_vol->status = GLUSTERD_STATUS_STOPPED;
ret = glusterd_store_volinfo (snap_vol,
GLUSTERD_VOLINFO_VER_AC_INCREMENT);
@ -5713,8 +5722,9 @@ glusterd_snapshot_create_commit (dict_t *dict, char **op_errstr,
goto out;
}
list_for_each_entry (snap_vol, &snap->volumes, vol_list) {
list_for_each_entry (brickinfo, &snap_vol->bricks, brick_list) {
cds_list_for_each_entry (snap_vol, &snap->volumes, vol_list) {
cds_list_for_each_entry (brickinfo, &snap_vol->bricks,
brick_list) {
ret = glusterd_brick_start (snap_vol, brickinfo,
_gf_false);
if (ret) {
@ -6287,15 +6297,15 @@ glusterd_get_single_snap_status (char **op_errstr, dict_t *rsp_dict,
GF_ASSERT (keyprefix);
GF_ASSERT (snap);
list_for_each_entry_safe (snap_volinfo, tmp_volinfo, &snap->volumes,
vol_list) {
cds_list_for_each_entry_safe (snap_volinfo, tmp_volinfo, &snap->volumes,
vol_list) {
ret = snprintf (key, sizeof (key), "%s.vol%d", keyprefix,
volcount);
if (ret < 0) {
goto out;
}
list_for_each_entry (brickinfo, &snap_volinfo->bricks,
brick_list) {
cds_list_for_each_entry (brickinfo, &snap_volinfo->bricks,
brick_list) {
if (!glusterd_is_local_brick (this, snap_volinfo,
brickinfo)) {
brickcount++;
@ -6457,8 +6467,8 @@ glusterd_get_snap_status_of_volume (char **op_errstr, dict_t *rsp_dict,
goto out;
}
list_for_each_entry_safe (snap_volinfo, temp_volinfo,
&volinfo->snap_volumes, snapvol_list) {
cds_list_for_each_entry_safe (snap_volinfo, temp_volinfo,
&volinfo->snap_volumes, snapvol_list) {
ret = snprintf (key, sizeof (key),
"status.snap%d.snapname", i);
if (ret < 0) {
@ -6506,8 +6516,8 @@ glusterd_get_all_snapshot_status (dict_t *dict, char **op_errstr,
GF_ASSERT (dict);
GF_ASSERT (op_errstr);
list_for_each_entry_safe (snap, tmp_snap,
&priv->snapshots, snap_list) {
cds_list_for_each_entry_safe (snap, tmp_snap, &priv->snapshots,
snap_list) {
ret = snprintf (key, sizeof (key),
"status.snap%d.snapname", i);
if (ret < 0) {
@ -6717,8 +6727,8 @@ glusterd_handle_snap_limit (dict_t *dict, dict_t *rsp_dict)
if (count <= 0)
goto out;
tmp_volinfo = list_entry (volinfo->snap_volumes.next,
glusterd_volinfo_t, snapvol_list);
tmp_volinfo = cds_list_entry (volinfo->snap_volumes.next,
glusterd_volinfo_t, snapvol_list);
snap = tmp_volinfo->snapshot;
GF_ASSERT (snap);
@ -7280,10 +7290,10 @@ glusterd_snapshot_revert_partial_restored_vol (glusterd_volinfo_t *volinfo)
/* Retrieve the snap_volumes list from the older volinfo */
reverted_vol->snap_count = volinfo->snap_count;
list_for_each_entry_safe (snap_vol, tmp_vol, &volinfo->snap_volumes,
snapvol_list) {
list_add_tail (&snap_vol->snapvol_list,
&reverted_vol->snap_volumes);
cds_list_for_each_entry_safe (snap_vol, tmp_vol, &volinfo->snap_volumes,
snapvol_list) {
cds_list_add_tail (&snap_vol->snapvol_list,
&reverted_vol->snap_volumes);
}
/* Since we retrieved the volinfo from store now we don't
@ -7323,8 +7333,8 @@ glusterd_snapshot_revert_restore_from_snap (glusterd_snap_t *snap)
/* TODO : As of now there is only one volume in snapshot.
* Change this when multiple volume snapshot is introduced
*/
snap_volinfo = list_entry (snap->volumes.next, glusterd_volinfo_t,
vol_list);
snap_volinfo = cds_list_entry (snap->volumes.next, glusterd_volinfo_t,
vol_list);
strcpy (volname, snap_volinfo->parent_volname);
@ -7798,9 +7808,9 @@ glusterd_free_missed_snapinfo (glusterd_missed_snap_info *missed_snapinfo)
glusterd_snap_op_t *tmp = NULL;
if (missed_snapinfo) {
list_for_each_entry_safe (snap_opinfo, tmp,
&missed_snapinfo->snap_ops,
snap_ops_list) {
cds_list_for_each_entry_safe (snap_opinfo, tmp,
&missed_snapinfo->snap_ops,
snap_ops_list) {
glusterd_free_snap_op (snap_opinfo);
snap_opinfo = NULL;
}
@ -7830,8 +7840,8 @@ glusterd_update_missed_snap_entry (glusterd_missed_snap_info *missed_snapinfo,
GF_ASSERT(missed_snapinfo);
GF_ASSERT(missed_snap_op);
list_for_each_entry (snap_opinfo, &missed_snapinfo->snap_ops,
snap_ops_list) {
cds_list_for_each_entry (snap_opinfo, &missed_snapinfo->snap_ops,
snap_ops_list) {
/* If the entry is not for the same snap_vol_id
* then continue
*/
@ -7894,8 +7904,8 @@ glusterd_update_missed_snap_entry (glusterd_missed_snap_info *missed_snapinfo,
"Duplicate entry. Not updating");
glusterd_free_snap_op (missed_snap_op);
} else {
list_add_tail (&missed_snap_op->snap_ops_list,
&missed_snapinfo->snap_ops);
cds_list_add_tail (&missed_snap_op->snap_ops_list,
&missed_snapinfo->snap_ops);
}
ret = 0;
@ -7955,8 +7965,8 @@ glusterd_add_new_entry_to_list (char *missed_info, char *snap_vol_id,
missed_snap_op->status = snap_status;
/* Look for other entries for the same node and same snap */
list_for_each_entry (missed_snapinfo, &priv->missed_snaps_list,
missed_snaps) {
cds_list_for_each_entry (missed_snapinfo, &priv->missed_snaps_list,
missed_snaps) {
snprintf (node_snap_info, sizeof(node_snap_info),
"%s:%s", missed_snapinfo->node_uuid,
missed_snapinfo->snap_uuid);
@ -7999,10 +8009,10 @@ glusterd_add_new_entry_to_list (char *missed_info, char *snap_vol_id,
goto out;
}
list_add_tail (&missed_snap_op->snap_ops_list,
&missed_snapinfo->snap_ops);
list_add_tail (&missed_snapinfo->missed_snaps,
&priv->missed_snaps_list);
cds_list_add_tail (&missed_snap_op->snap_ops_list,
&missed_snapinfo->snap_ops);
cds_list_add_tail (&missed_snapinfo->missed_snaps,
&priv->missed_snaps_list);
ret = 0;
goto out;
@ -8253,7 +8263,7 @@ gd_restore_snap_volume (dict_t *dict, dict_t *rsp_dict,
* set the status to the original volume's status. */
glusterd_set_volume_status (new_volinfo, orig_vol->status);
list_add_tail (&new_volinfo->vol_list, &conf->volumes);
cds_list_add_tail (&new_volinfo->vol_list, &conf->volumes);
ret = glusterd_store_volinfo (new_volinfo,
GLUSTERD_VOLINFO_VER_AC_INCREMENT);
@ -8272,10 +8282,11 @@ out:
if (new_volinfo)
(void)glusterd_volinfo_delete (new_volinfo);
} else {
list_for_each_entry_safe (voliter, temp_volinfo,
&orig_vol->snap_volumes, snapvol_list) {
list_add_tail (&voliter->snapvol_list,
&new_volinfo->snap_volumes);
cds_list_for_each_entry_safe (voliter, temp_volinfo,
&orig_vol->snap_volumes,
snapvol_list) {
cds_list_add_tail (&voliter->snapvol_list,
&new_volinfo->snap_volumes);
}
}
@ -8317,8 +8328,8 @@ glusterd_snapshot_get_volnames_uuids (dict_t *dict,
goto out;
}
list_for_each_entry_safe (snap_vol, tmp_vol, &volinfo->snap_volumes,
snapvol_list) {
cds_list_for_each_entry_safe (snap_vol, tmp_vol, &volinfo->snap_volumes,
snapvol_list) {
if (GLUSTERD_STATUS_STARTED != snap_vol->status)
continue;

62
xlators/mgmt/glusterd/src/glusterd-store.c
View File

@ -622,7 +622,7 @@ glusterd_store_remove_bricks (glusterd_volinfo_t *volinfo, char *delete_path)
GF_ASSERT (volinfo);
list_for_each_entry (tmp, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (tmp, &volinfo->bricks, brick_list) {
ret = glusterd_store_delete_brick (tmp, delete_path);
if (ret)
goto out;
@ -1238,7 +1238,7 @@ glusterd_store_brickinfos (glusterd_volinfo_t *volinfo, int vol_fd)
GF_ASSERT (volinfo);
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
ret = glusterd_store_brickinfo (volinfo, brickinfo,
brick_count, vol_fd);
if (ret)
@ -1476,7 +1476,7 @@ glusterd_store_bricks_cleanup_tmp (glusterd_volinfo_t *volinfo)
GF_ASSERT (volinfo);
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
gf_store_unlink_tmppath (brickinfo->shandle);
}
}
@ -1505,7 +1505,7 @@ glusterd_store_brickinfos_atomic_update (glusterd_volinfo_t *volinfo)
GF_ASSERT (volinfo);
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
ret = gf_store_rename_tmppath (brickinfo->shandle);
if (ret)
goto out;
@ -2373,7 +2373,7 @@ glusterd_store_retrieve_bricks (glusterd_volinfo_t *volinfo)
brickid++);
}
list_add_tail (&brickinfo->brick_list, &volinfo->bricks);
cds_list_add_tail (&brickinfo->brick_list, &volinfo->bricks);
brick_count++;
}
@ -2901,8 +2901,9 @@ glusterd_store_retrieve_volume (char *volname, glusterd_snap_t *snap)
if (!snap) {
list_add_order (&volinfo->vol_list, &priv->volumes,
glusterd_compare_volume_name);
glusterd_list_add_order (&volinfo->vol_list, &priv->volumes,
glusterd_compare_volume_name);
} else {
ret = glusterd_volinfo_find (volinfo->parent_volname,
&origin_volinfo);
@ -3231,7 +3232,7 @@ glusterd_recreate_vol_brick_mounts (xlator_t *this,
GF_ASSERT (volinfo);
brick_count = 0;
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
brick_count++;
/* If the brick is not of this node, or its
* snapshot is pending, or the brick is not
@ -3309,8 +3310,9 @@ glusterd_resolve_snap_bricks (xlator_t *this, glusterd_snap_t *snap)
GF_ASSERT (this);
GF_VALIDATE_OR_GOTO (this->name, snap, out);
list_for_each_entry (volinfo, &snap->volumes, vol_list) {
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (volinfo, &snap->volumes, vol_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
ret = glusterd_resolve_brick (brickinfo);
if (ret) {
gf_log (this->name, GF_LOG_ERROR,
@ -3453,8 +3455,8 @@ glusterd_store_retrieve_snap (char *snapname)
/* TODO: list_add_order can do 'N-square' comparisions and
is not efficient. Find a better solution to store the snap
in order */
list_add_order (&snap->snap_list, &priv->snapshots,
glusterd_compare_snap_time);
glusterd_list_add_order (&snap->snap_list, &priv->snapshots,
glusterd_compare_snap_time);
out:
gf_log (this->name, GF_LOG_TRACE, "Returning with %d", ret);
@ -3635,11 +3637,11 @@ glusterd_store_write_missed_snapinfo (int32_t fd)
GF_ASSERT (priv);
/* Write the missed_snap_entry */
list_for_each_entry (missed_snapinfo, &priv->missed_snaps_list,
missed_snaps) {
list_for_each_entry (snap_opinfo,
&missed_snapinfo->snap_ops,
snap_ops_list) {
cds_list_for_each_entry (missed_snapinfo, &priv->missed_snaps_list,
missed_snaps) {
cds_list_for_each_entry (snap_opinfo,
&missed_snapinfo->snap_ops,
snap_ops_list) {
snprintf (key, sizeof(key), "%s:%s",
missed_snapinfo->node_uuid,
missed_snapinfo->snap_uuid);
@ -3911,7 +3913,8 @@ glusterd_store_peer_write (int fd, glusterd_peerinfo_t *peerinfo)
if (ret)
goto out;
list_for_each_entry (hostname, &peerinfo->hostnames, hostname_list) {
cds_list_for_each_entry (hostname, &peerinfo->hostnames,
hostname_list) {
ret = gf_asprintf (&key, GLUSTERD_STORE_KEY_PEER_HOSTNAME"%d",
i);
if (ret < 0)
@ -4074,8 +4077,9 @@ glusterd_store_retrieve_peers (xlator_t *this)
/* Set first hostname from peerinfo->hostnames to
* peerinfo->hostname
*/
address = list_entry (peerinfo->hostnames.next,
glusterd_peer_hostname_t, hostname_list);
address = cds_list_entry (peerinfo->hostnames.next,
glusterd_peer_hostname_t,
hostname_list);
if (!address) {
ret = -1;
goto out;
@ -4092,7 +4096,7 @@ glusterd_store_retrieve_peers (xlator_t *this)
}
args.mode = GD_MODE_ON;
list_for_each_entry (peerinfo, &priv->peers, uuid_list) {
cds_list_for_each_entry (peerinfo, &priv->peers, uuid_list) {
ret = glusterd_friend_rpc_create (this, peerinfo, &args);
if (ret)
goto out;
@ -4128,7 +4132,7 @@ glusterd_recreate_all_snap_brick_mounts (xlator_t *this)
GF_ASSERT (priv);
/* Recreate bricks of volumes restored from snaps */
list_for_each_entry (volinfo, &priv->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &priv->volumes, vol_list) {
/* If the volume is not a restored volume then continue */
if (uuid_is_null (volinfo->restored_from_snap))
continue;
@ -4143,8 +4147,8 @@ glusterd_recreate_all_snap_brick_mounts (xlator_t *this)
}
/* Recreate bricks of snapshot volumes */
list_for_each_entry (snap, &priv->snapshots, snap_list) {
list_for_each_entry (volinfo, &snap->volumes, vol_list) {
cds_list_for_each_entry (snap, &priv->snapshots, snap_list) {
cds_list_for_each_entry (volinfo, &snap->volumes, vol_list) {
ret = glusterd_recreate_vol_brick_mounts (this,
volinfo);
if (ret) {
@ -4195,7 +4199,8 @@ glusterd_snap_cleanup (xlator_t *this)
goto out;
}
list_for_each_entry_safe (snap, tmp_snap, &priv->snapshots, snap_list) {
cds_list_for_each_entry_safe (snap, tmp_snap, &priv->snapshots,
snap_list) {
if (snap->snap_status == GD_SNAP_STATUS_RESTORED) {
ret = glusterd_snapshot_revert_restore_from_snap (snap);
if (ret) {
@ -4238,8 +4243,9 @@ glusterd_resolve_all_bricks (xlator_t *this)
GF_ASSERT (priv);
/* Resolve bricks of volumes */
list_for_each_entry (volinfo, &priv->volumes, vol_list) {
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (volinfo, &priv->volumes, vol_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
ret = glusterd_resolve_brick (brickinfo);
if (ret) {
gf_log ("glusterd", GF_LOG_ERROR,
@ -4250,7 +4256,7 @@ glusterd_resolve_all_bricks (xlator_t *this)
}
/* Resolve bricks of snapshot volumes */
list_for_each_entry (snap, &priv->snapshots, snap_list) {
cds_list_for_each_entry (snap, &priv->snapshots, snap_list) {
ret = glusterd_resolve_snap_bricks (this, snap);
if (ret) {
gf_log (this->name, GF_LOG_ERROR,

2
xlators/mgmt/glusterd/src/glusterd-svc-mgmt.c
View File

@ -307,7 +307,7 @@ glusterd_svc_common_rpc_notify (glusterd_conn_t *conn,
GF_ASSERT (this);
/* Get the parent onject i.e. svc using list_entry macro */
svc = list_entry (conn, glusterd_svc_t, conn);
svc = cds_list_entry (conn, glusterd_svc_t, conn);
if (!svc) {
gf_log (this->name, GF_LOG_ERROR, "Failed to get the service");
return -1;

53
xlators/mgmt/glusterd/src/glusterd-syncop.c
View File

@ -1067,8 +1067,8 @@ out:
int
gd_build_peers_list (struct list_head *peers, struct list_head *xact_peers,
glusterd_op_t op)
gd_build_peers_list (struct cds_list_head *peers,
struct cds_list_head *xact_peers, glusterd_op_t op)
{
glusterd_peerinfo_t *peerinfo = NULL;
int npeers = 0;
@ -1076,22 +1076,22 @@ gd_build_peers_list (struct list_head *peers, struct list_head *xact_peers,
GF_ASSERT (peers);
GF_ASSERT (xact_peers);
list_for_each_entry (peerinfo, peers, uuid_list) {
cds_list_for_each_entry (peerinfo, peers, uuid_list) {
if (!peerinfo->connected)
continue;
if (op != GD_OP_SYNC_VOLUME &&
peerinfo->state.state != GD_FRIEND_STATE_BEFRIENDED)
continue;
list_add_tail (&peerinfo->op_peers_list, xact_peers);
cds_list_add_tail (&peerinfo->op_peers_list, xact_peers);
npeers++;
}
return npeers;
}
int
gd_build_local_xaction_peers_list (struct list_head *peers,
struct list_head *xact_peers,
gd_build_local_xaction_peers_list (struct cds_list_head *peers,
struct cds_list_head *xact_peers,
glusterd_op_t op)
{
glusterd_peerinfo_t *peerinfo = NULL;
@ -1101,7 +1101,7 @@ gd_build_local_xaction_peers_list (struct list_head *peers,
GF_ASSERT (peers);
GF_ASSERT (xact_peers);
list_for_each_entry (peerinfo, peers, uuid_list) {
cds_list_for_each_entry (peerinfo, peers, uuid_list) {
if (!peerinfo->connected)
continue;
if (op != GD_OP_SYNC_VOLUME &&
@ -1113,26 +1113,27 @@ gd_build_local_xaction_peers_list (struct list_head *peers,
if (!local_peers) {
return -1;
}
INIT_LIST_HEAD (&local_peers->op_peers_list);
CDS_INIT_LIST_HEAD (&local_peers->op_peers_list);
local_peers->peerinfo = peerinfo;
list_add_tail (&local_peers->op_peers_list, xact_peers);
cds_list_add_tail (&local_peers->op_peers_list, xact_peers);
npeers++;
}
return npeers;
}
void
gd_cleanup_local_xaction_peers_list (struct list_head *xact_peers)
gd_cleanup_local_xaction_peers_list (struct cds_list_head *xact_peers)
{
glusterd_local_peers_t *local_peers = NULL;
glusterd_local_peers_t *tmp = NULL;
GF_ASSERT (xact_peers);
if (list_empty (xact_peers))
if (cds_list_empty (xact_peers))
return;
list_for_each_entry_safe (local_peers, tmp, xact_peers, op_peers_list) {
cds_list_for_each_entry_safe (local_peers, tmp, xact_peers,
op_peers_list) {
GF_FREE (local_peers);
/* local_peers->peerinfo need not be freed because it does not
* ownership of peerinfo, but merely refer it */
@ -1142,7 +1143,7 @@ gd_cleanup_local_xaction_peers_list (struct list_head *xact_peers)
int
gd_lock_op_phase (glusterd_conf_t *conf, glusterd_op_t op, dict_t *op_ctx,
char **op_errstr, int npeers, uuid_t txn_id,
struct list_head *peers)
struct cds_list_head *peers)
{
int ret = -1;
int peer_cnt = 0;
@ -1197,8 +1198,9 @@ out:
}
int
gd_stage_op_phase (struct list_head *peers, glusterd_op_t op, dict_t *op_ctx,
dict_t *req_dict, char **op_errstr, int npeers)
gd_stage_op_phase (struct cds_list_head *peers, glusterd_op_t op,
dict_t *op_ctx, dict_t *req_dict, char **op_errstr,
int npeers)
{
int ret = -1;
int peer_cnt = 0;
@ -1304,8 +1306,9 @@ out:
}
int
gd_commit_op_phase (struct list_head *peers, glusterd_op_t op, dict_t *op_ctx,
dict_t *req_dict, char **op_errstr, int npeers)
gd_commit_op_phase (struct cds_list_head *peers, glusterd_op_t op,
dict_t *op_ctx, dict_t *req_dict, char **op_errstr,
int npeers)
{
dict_t *rsp_dict = NULL;
int peer_cnt = -1;
@ -1407,7 +1410,7 @@ int
gd_unlock_op_phase (glusterd_conf_t *conf, glusterd_op_t op, int *op_ret,
rpcsvc_request_t *req, dict_t *op_ctx, char *op_errstr,
int npeers, char *volname, gf_boolean_t is_acquired,
uuid_t txn_id, struct list_head *peers)
uuid_t txn_id, struct cds_list_head *peers)
{
glusterd_peerinfo_t *peerinfo = NULL;
uuid_t tmp_uuid = {0};
@ -1505,11 +1508,11 @@ out:
}
int
gd_get_brick_count (struct list_head *bricks)
gd_get_brick_count (struct cds_list_head *bricks)
{
glusterd_pending_node_t *pending_node = NULL;
int npeers = 0;
list_for_each_entry (pending_node, bricks, list) {
cds_list_for_each_entry (pending_node, bricks, list) {
npeers++;
}
return npeers;
@ -1520,7 +1523,7 @@ gd_brick_op_phase (glusterd_op_t op, dict_t *op_ctx, dict_t *req_dict,
char **op_errstr)
{
glusterd_pending_node_t *pending_node = NULL;
struct list_head selected = {0,};
struct cds_list_head selected = {0,};
xlator_t *this = NULL;
int brick_count = 0;
int ret = -1;
@ -1536,7 +1539,7 @@ gd_brick_op_phase (glusterd_op_t op, dict_t *op_ctx, dict_t *req_dict,
goto out;
}
INIT_LIST_HEAD (&selected);
CDS_INIT_LIST_HEAD (&selected);
ret = glusterd_op_bricks_select (op, req_dict, op_errstr, &selected,
rsp_dict);
if (ret) {
@ -1555,7 +1558,7 @@ gd_brick_op_phase (glusterd_op_t op, dict_t *op_ctx, dict_t *req_dict,
rsp_dict = NULL;
brick_count = 0;
list_for_each_entry (pending_node, &selected, list) {
cds_list_for_each_entry (pending_node, &selected, list) {
rpc = glusterd_pending_node_get_rpc (pending_node);
if (!rpc) {
if (pending_node->type == GD_NODE_REBALANCE) {
@ -1603,7 +1606,7 @@ gd_sync_task_begin (dict_t *op_ctx, rpcsvc_request_t * req)
xlator_t *this = NULL;
gf_boolean_t is_acquired = _gf_false;
uuid_t *txn_id = NULL;
struct list_head xaction_peers = {0,};
struct cds_list_head xaction_peers = {0,};
glusterd_op_info_t txn_opinfo;
this = THIS;
@ -1611,7 +1614,7 @@ gd_sync_task_begin (dict_t *op_ctx, rpcsvc_request_t * req)
conf = this->private;
GF_ASSERT (conf);
INIT_LIST_HEAD (&xaction_peers);
CDS_INIT_LIST_HEAD (&xaction_peers);
ret = dict_get_int32 (op_ctx, GD_SYNC_OPCODE_KEY, &tmp_op);
if (ret) {

28
xlators/mgmt/glusterd/src/glusterd-syncop.h
View File

@ -37,15 +37,15 @@
} while (0)
#define list_for_each_local_xaction_peers(xact_peer, xact_peers_head) \
glusterd_local_peers_t *pos = NULL; \
for (pos = list_entry((xact_peers_head)->next, glusterd_local_peers_t,\
op_peers_list), \
xact_peer = pos->peerinfo; \
&pos->op_peers_list != (xact_peers_head); \
pos = list_entry(pos->op_peers_list.next, glusterd_local_peers_t,\
op_peers_list), \
xact_peer = pos->peerinfo)
#define list_for_each_local_xaction_peers(xact_peer, xact_peers_head) \
glusterd_local_peers_t *pos = NULL; \
for (pos = cds_list_entry ((xact_peers_head)->next, \
glusterd_local_peers_t, op_peers_list), \
xact_peer = pos->peerinfo; \
&pos->op_peers_list != (xact_peers_head); \
pos = cds_list_entry(pos->op_peers_list.next, \
glusterd_local_peers_t, op_peers_list), \
xact_peer = pos->peerinfo)
int gd_syncop_submit_request (struct rpc_clnt *rpc, void *req, void *local,
void *cookie, rpc_clnt_prog_t *prog, int procnum,
@ -70,16 +70,16 @@ void
gd_synctask_barrier_wait (struct syncargs *args, int count);
int
gd_build_peers_list (struct list_head *peers, struct list_head *xact_peers,
glusterd_op_t op);
gd_build_peers_list (struct cds_list_head *peers,
struct cds_list_head *xact_peers, glusterd_op_t op);
int
gd_build_local_xaction_peers_list (struct list_head *peers,
struct list_head *xact_peers,
gd_build_local_xaction_peers_list (struct cds_list_head *peers,
struct cds_list_head *xact_peers,
glusterd_op_t op);
void
gd_cleanup_local_xaction_peers_list (struct list_head *peers);
gd_cleanup_local_xaction_peers_list (struct cds_list_head *peers);
int
gd_brick_op_phase (glusterd_op_t op, dict_t *op_ctx, dict_t *req_dict,

202
xlators/mgmt/glusterd/src/glusterd-utils.c
View File

@ -477,10 +477,10 @@ glusterd_volinfo_new (glusterd_volinfo_t **volinfo)
goto out;
LOCK_INIT (&new_volinfo->lock);
INIT_LIST_HEAD (&new_volinfo->vol_list);
INIT_LIST_HEAD (&new_volinfo->snapvol_list);
INIT_LIST_HEAD (&new_volinfo->bricks);
INIT_LIST_HEAD (&new_volinfo->snap_volumes);
CDS_INIT_LIST_HEAD (&new_volinfo->vol_list);
CDS_INIT_LIST_HEAD (&new_volinfo->snapvol_list);
CDS_INIT_LIST_HEAD (&new_volinfo->bricks);
CDS_INIT_LIST_HEAD (&new_volinfo->snap_volumes);
new_volinfo->dict = dict_new ();
if (!new_volinfo->dict) {
@ -709,7 +709,7 @@ glusterd_brickinfo_delete (glusterd_brickinfo_t *brickinfo)
GF_ASSERT (brickinfo);
list_del_init (&brickinfo->brick_list);
cds_list_del_init (&brickinfo->brick_list);
GF_FREE (brickinfo->logfile);
GF_FREE (brickinfo);
@ -728,8 +728,8 @@ glusterd_volume_brickinfos_delete (glusterd_volinfo_t *volinfo)
GF_ASSERT (volinfo);
list_for_each_entry_safe (brickinfo, tmp, &volinfo->bricks,
brick_list) {
cds_list_for_each_entry_safe (brickinfo, tmp, &volinfo->bricks,
brick_list) {
ret = glusterd_brickinfo_delete (brickinfo);
if (ret)
goto out;
@ -743,7 +743,7 @@ out:
int
glusterd_volinfo_remove (glusterd_volinfo_t *volinfo)
{
list_del_init (&volinfo->vol_list);
cds_list_del_init (&volinfo->vol_list);
glusterd_volinfo_unref (volinfo);
return 0;
}
@ -755,8 +755,8 @@ glusterd_volinfo_delete (glusterd_volinfo_t *volinfo)
GF_ASSERT (volinfo);
list_del_init (&volinfo->vol_list);
list_del_init (&volinfo->snapvol_list);
cds_list_del_init (&volinfo->vol_list);
cds_list_del_init (&volinfo->snapvol_list);
ret = glusterd_volume_brickinfos_delete (volinfo);
if (ret)
@ -798,7 +798,7 @@ glusterd_brickinfo_new (glusterd_brickinfo_t **brickinfo)
if (!new_brickinfo)
goto out;
INIT_LIST_HEAD (&new_brickinfo->brick_list);
CDS_INIT_LIST_HEAD (&new_brickinfo->brick_list);
*brickinfo = new_brickinfo;
@ -818,7 +818,7 @@ glusterd_get_next_available_brickid (glusterd_volinfo_t *volinfo)
int max_brickid = -1;
int ret = -1;
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
token = strrchr (brickinfo->brick_id, '-');
ret = gf_string2int32 (++token, &brickid);
if (ret < 0) {
@ -1025,8 +1025,9 @@ glusterd_is_brickpath_available (uuid_t uuid, char *path)
strncpy(tmp_path,path,PATH_MAX);
}
list_for_each_entry (volinfo, &priv->volumes, vol_list) {
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (volinfo, &priv->volumes, vol_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
if (uuid_compare (uuid, brickinfo->uuid))
continue;
@ -1331,7 +1332,7 @@ glusterd_volume_brickinfo_get (uuid_t uuid, char *hostname, char *path,
goto out;
}
ret = -1;
list_for_each_entry (brickiter, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickiter, &volinfo->bricks, brick_list) {
if ((uuid_is_null (brickiter->uuid)) &&
(glusterd_resolve_brick (brickiter) != 0))
@ -1410,7 +1411,7 @@ glusterd_volinfo_find_by_volume_id (uuid_t volume_id, glusterd_volinfo_t **volin
this = THIS;
priv = this->private;
list_for_each_entry (voliter, &priv->volumes, vol_list) {
cds_list_for_each_entry (voliter, &priv->volumes, vol_list) {
if (uuid_compare (volume_id, voliter->volume_id))
continue;
*volinfo = voliter;
@ -1437,7 +1438,7 @@ glusterd_volinfo_find (char *volname, glusterd_volinfo_t **volinfo)
priv = this->private;
GF_ASSERT (priv);
list_for_each_entry (tmp_volinfo, &priv->volumes, vol_list) {
cds_list_for_each_entry (tmp_volinfo, &priv->volumes, vol_list) {
if (!strcmp (tmp_volinfo->volname, volname)) {
gf_log (this->name, GF_LOG_DEBUG, "Volume %s found",
volname);
@ -1845,7 +1846,7 @@ glusterd_volume_stop_glusterfs (glusterd_volinfo_t *volinfo,
priv = this->private;
if (del_brick)
list_del_init (&brickinfo->brick_list);
cds_list_del_init (&brickinfo->brick_list);
if (GLUSTERD_STATUS_STARTED == volinfo->status) {
(void) glusterd_brick_disconnect (brickinfo);
@ -2145,7 +2146,7 @@ glusterd_add_bricks_hname_path_to_dict (dict_t *dict,
int index = 0;
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
snprintf (key, sizeof (key), "%d-hostname", index);
ret = dict_set_str (dict, key, brickinfo->hostname);
if (ret)
@ -2420,7 +2421,7 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo,
if (ret)
goto out;
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
memset (key, 0, sizeof (key));
snprintf (key, sizeof (key), "%s%d.brick%d.hostname",
prefix, count, i);
@ -2598,7 +2599,7 @@ glusterd_add_volumes_to_export_dict (dict_t **peer_data)
if (!dict)
goto out;
list_for_each_entry (volinfo, &priv->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &priv->volumes, vol_list) {
count++;
ret = glusterd_add_volume_to_dict (volinfo, dict, count,
"volume");
@ -2898,7 +2899,7 @@ _does_quorum_meet (int active_count, int quorum_count)
int
glusterd_get_quorum_cluster_counts (xlator_t *this, int *active_count,
int *quorum_count,
struct list_head *peer_list,
struct cds_list_head *peer_list,
gf_boolean_t _local_xaction_peers)
{
glusterd_peerinfo_t *peerinfo = NULL;
@ -2918,7 +2919,7 @@ glusterd_get_quorum_cluster_counts (xlator_t *this, int *active_count,
*active_count = 1;
if (!peer_list) {
list_for_each_entry (peerinfo, &conf->peers, uuid_list) {
cds_list_for_each_entry (peerinfo, &conf->peers, uuid_list) {
glusterd_quorum_count(peerinfo, inquorum_count,
active_count, out);
}
@ -2930,8 +2931,8 @@ glusterd_get_quorum_cluster_counts (xlator_t *this, int *active_count,
active_count, out);
}
} else {
list_for_each_entry (peerinfo, peer_list,
op_peers_list) {
cds_list_for_each_entry (peerinfo, peer_list,
op_peers_list) {
glusterd_quorum_count(peerinfo, inquorum_count,
active_count, out);
}
@ -2981,7 +2982,7 @@ glusterd_is_any_volume_in_server_quorum (xlator_t *this)
glusterd_volinfo_t *volinfo = NULL;
conf = this->private;
list_for_each_entry (volinfo, &conf->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &conf->volumes, vol_list) {
if (glusterd_is_volume_in_server_quorum (volinfo)) {
return _gf_true;
}
@ -2990,7 +2991,7 @@ glusterd_is_any_volume_in_server_quorum (xlator_t *this)
}
gf_boolean_t
does_gd_meet_server_quorum (xlator_t *this, struct list_head *peers_list,
does_gd_meet_server_quorum (xlator_t *this, struct cds_list_head *peers_list,
gf_boolean_t _local_xaction_peers)
{
int quorum_count = 0;
@ -3085,7 +3086,7 @@ glusterd_do_volume_quorum_action (xlator_t *this, glusterd_volinfo_t *volinfo,
"bricks.", volinfo->volname);
}
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
if (!glusterd_is_local_brick (this, volinfo, brickinfo))
continue;
if (quorum_status == DOESNT_MEET_QUORUM)
@ -3126,7 +3127,7 @@ glusterd_do_quorum_action ()
if (_does_quorum_meet (active_count, quorum_count))
meets = _gf_true;
list_for_each_entry (volinfo, &conf->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &conf->volumes, vol_list) {
glusterd_do_volume_quorum_action (this, volinfo, meets);
}
}
@ -3309,7 +3310,8 @@ glusterd_import_bricks (dict_t *peer_data, int32_t vol_count,
GLUSTERD_ASSIGN_BRICKID_TO_BRICKINFO (new_brickinfo,
new_volinfo,
brickid++);
list_add_tail (&new_brickinfo->brick_list, &new_volinfo->bricks);
cds_list_add_tail (&new_brickinfo->brick_list,
&new_volinfo->bricks);
brick_count++;
}
ret = 0;
@ -3821,7 +3823,7 @@ glusterd_volume_disconnect_all_bricks (glusterd_volinfo_t *volinfo)
glusterd_brickinfo_t *brickinfo = NULL;
GF_ASSERT (volinfo);
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
if (glusterd_is_brick_started (brickinfo)) {
ret = glusterd_brick_disconnect (brickinfo);
if (ret) {
@ -3857,11 +3859,13 @@ glusterd_volinfo_copy_brick_portinfo (glusterd_volinfo_t *new_volinfo,
if (_gf_false == glusterd_is_volume_started (new_volinfo))
goto out;
list_for_each_entry (new_brickinfo, &new_volinfo->bricks, brick_list) {
cds_list_for_each_entry (new_brickinfo, &new_volinfo->bricks,
brick_list) {
ret = glusterd_volume_brickinfo_get (new_brickinfo->uuid,
new_brickinfo->hostname,
new_brickinfo->path,
old_volinfo, &old_brickinfo);
old_volinfo,
&old_brickinfo);
if (ret == 0) {
GLUSTERD_GET_BRICK_PIDFILE (pidfile, old_volinfo,
old_brickinfo, priv);
@ -3887,11 +3891,13 @@ glusterd_volinfo_stop_stale_bricks (glusterd_volinfo_t *new_volinfo,
GF_ASSERT (old_volinfo);
if (_gf_false == glusterd_is_volume_started (old_volinfo))
goto out;
list_for_each_entry (old_brickinfo, &old_volinfo->bricks, brick_list) {
cds_list_for_each_entry (old_brickinfo, &old_volinfo->bricks,
brick_list) {
ret = glusterd_volume_brickinfo_get (old_brickinfo->uuid,
old_brickinfo->hostname,
old_brickinfo->path,
new_volinfo, &new_brickinfo);
new_volinfo,
&new_brickinfo);
/* If the brick is stale, i.e it's not a part of the new volume
* or if it's part of the new volume and is pending a snap,
* then stop the brick process
@ -3932,10 +3938,11 @@ glusterd_delete_stale_volume (glusterd_volinfo_t *stale_volinfo,
/* Copy snap_volumes list from stale_volinfo to valid_volinfo */
valid_volinfo->snap_count = 0;
list_for_each_entry_safe (voliter, temp_volinfo,
&stale_volinfo->snap_volumes, snapvol_list) {
list_add_tail (&voliter->snapvol_list,
&valid_volinfo->snap_volumes);
cds_list_for_each_entry_safe (voliter, temp_volinfo,
&stale_volinfo->snap_volumes,
snapvol_list) {
cds_list_add_tail (&voliter->snapvol_list,
&valid_volinfo->snap_volumes);
valid_volinfo->snap_count++;
}
@ -4110,8 +4117,9 @@ glusterd_import_friend_volume (dict_t *peer_data, size_t count)
if (ret)
goto out;
list_add_order (&new_volinfo->vol_list, &priv->volumes,
glusterd_compare_volume_name);
glusterd_list_add_order (&new_volinfo->vol_list, &priv->volumes,
glusterd_compare_volume_name);
out:
gf_log ("", GF_LOG_DEBUG, "Returning with ret: %d", ret);
return ret;
@ -4534,7 +4542,7 @@ glusterd_are_all_volumes_stopped ()
priv = this->private;
GF_ASSERT (priv);
list_for_each_entry (voliter, &priv->volumes, vol_list) {
cds_list_for_each_entry (voliter, &priv->volumes, vol_list) {
if (voliter->status == GLUSTERD_STATUS_STARTED)
return _gf_false;
}
@ -4555,7 +4563,7 @@ glusterd_all_shd_compatible_volumes_stopped ()
priv = this->private;
GF_ASSERT (priv);
list_for_each_entry (voliter, &priv->volumes, vol_list) {
cds_list_for_each_entry (voliter, &priv->volumes, vol_list) {
if (!glusterd_is_shd_compatible_volume (voliter))
continue;
if (voliter->status == GLUSTERD_STATUS_STARTED)
@ -4577,7 +4585,7 @@ glusterd_all_volumes_with_quota_stopped ()
priv = this->private;
GF_ASSERT (priv);
list_for_each_entry (voliter, &priv->volumes, vol_list) {
cds_list_for_each_entry (voliter, &priv->volumes, vol_list) {
if (!glusterd_is_volume_quota_enabled (voliter))
continue;
if (voliter->status == GLUSTERD_STATUS_STARTED)
@ -4600,7 +4608,7 @@ glusterd_volume_count_get (void)
priv = this->private;
list_for_each_entry (tmp_volinfo, &priv->volumes, vol_list) {
cds_list_for_each_entry (tmp_volinfo, &priv->volumes, vol_list) {
ret++;
}
@ -4626,7 +4634,7 @@ glusterd_brickinfo_get (uuid_t uuid, char *hostname, char *path,
priv = this->private;
list_for_each_entry (volinfo, &priv->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &priv->volumes, vol_list) {
ret = glusterd_volume_brickinfo_get (uuid, hostname, path,
volinfo, brickinfo);
@ -4690,26 +4698,27 @@ glusterd_restart_bricks (glusterd_conf_t *conf)
this = THIS;
GF_ASSERT (this);
list_for_each_entry (volinfo, &conf->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &conf->volumes, vol_list) {
if (volinfo->status != GLUSTERD_STATUS_STARTED)
continue;
start_svcs = _gf_true;
gf_log (this->name, GF_LOG_DEBUG, "starting the volume %s",
volinfo->volname);
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
glusterd_brick_start (volinfo, brickinfo, _gf_false);
}
}
list_for_each_entry (snap, &conf->snapshots, snap_list) {
list_for_each_entry (volinfo, &snap->volumes, vol_list) {
cds_list_for_each_entry (snap, &conf->snapshots, snap_list) {
cds_list_for_each_entry (volinfo, &snap->volumes, vol_list) {
if (volinfo->status != GLUSTERD_STATUS_STARTED)
continue;
start_svcs = _gf_true;
gf_log (this->name, GF_LOG_DEBUG, "starting the snap "
"volume %s", volinfo->volname);
list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
glusterd_brick_start (volinfo, brickinfo,
_gf_false);
}
@ -4911,7 +4920,7 @@ glusterd_restart_gsyncds (glusterd_conf_t *conf)
glusterd_volinfo_t *volinfo = NULL;
int ret = 0;
list_for_each_entry (volinfo, &conf->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &conf->volumes, vol_list) {
glusterd_volume_restart_gsyncds (volinfo);
}
return ret;
@ -4942,9 +4951,9 @@ glusterd_get_brickinfo (xlator_t *this, const char *brickname, int port,
GF_ASSERT (this);
priv = this->private;
list_for_each_entry (volinfo, &priv->volumes, vol_list) {
list_for_each_entry (tmpbrkinfo, &volinfo->bricks,
brick_list) {
cds_list_for_each_entry (volinfo, &priv->volumes, vol_list) {
cds_list_for_each_entry (tmpbrkinfo, &volinfo->bricks,
brick_list) {
if (localhost && !gf_is_local_addr (tmpbrkinfo->hostname))
continue;
if (!strcmp(tmpbrkinfo->path, brickname) &&
@ -4962,8 +4971,7 @@ glusterd_get_brickinfo_by_position (glusterd_volinfo_t *volinfo, uint32_t pos)
{
glusterd_brickinfo_t *tmpbrkinfo = NULL;
list_for_each_entry (tmpbrkinfo, &volinfo->bricks,
brick_list) {
cds_list_for_each_entry (tmpbrkinfo, &volinfo->bricks, brick_list) {
if (pos == 0)
return tmpbrkinfo;
pos--;
@ -5540,7 +5548,7 @@ glusterd_get_all_volnames (dict_t *dict)
priv = THIS->private;
GF_ASSERT (priv);
list_for_each_entry (entry, &priv->volumes, vol_list) {
cds_list_for_each_entry (entry, &priv->volumes, vol_list) {
memset (key, 0, sizeof (key));
snprintf (key, sizeof (key), "vol%d", vol_count);
ret = dict_set_str (dict, key, entry->volname);
@ -5572,9 +5580,9 @@ glusterd_all_volume_cond_check (glusterd_condition_func func, int status,
this = THIS;
priv = this->private;
list_for_each_entry (volinfo, &priv->volumes, vol_list) {
list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
cds_list_for_each_entry (volinfo, &priv->volumes, vol_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
ret = func (volinfo, brickinfo, ctx);
if (ret != status) {
ret = -1;
@ -6135,15 +6143,15 @@ out:
}
int
glusterd_remove_pending_entry (struct list_head *list, void *elem)
glusterd_remove_pending_entry (struct cds_list_head *list, void *elem)
{
glusterd_pending_node_t *pending_node = NULL;
glusterd_pending_node_t *tmp = NULL;
int ret = 0;
list_for_each_entry_safe (pending_node, tmp, list, list) {
cds_list_for_each_entry_safe (pending_node, tmp, list, list) {
if (elem == pending_node->node) {
list_del_init (&pending_node->list);
cds_list_del_init (&pending_node->list);
GF_FREE (pending_node);
ret = 0;
goto out;
@ -6156,13 +6164,13 @@ out:
}
int
glusterd_clear_pending_nodes (struct list_head *list)
glusterd_clear_pending_nodes (struct cds_list_head *list)
{
glusterd_pending_node_t *pending_node = NULL;
glusterd_pending_node_t *tmp = NULL;
list_for_each_entry_safe (pending_node, tmp, list, list) {
list_del_init (&pending_node->list);
cds_list_for_each_entry_safe (pending_node, tmp, list, list) {
cds_list_del_init (&pending_node->list);
GF_FREE (pending_node);
}
@ -6214,7 +6222,8 @@ glusterd_delete_all_bricks (glusterd_volinfo_t* volinfo)
GF_ASSERT (volinfo);
list_for_each_entry_safe (brickinfo, tmp, &volinfo->bricks, brick_list) {
cds_list_for_each_entry_safe (brickinfo, tmp, &volinfo->bricks,
brick_list) {
ret = glusterd_delete_brick (volinfo, brickinfo);
}
return ret;
@ -6244,7 +6253,7 @@ glusterd_get_local_brickpaths (glusterd_volinfo_t *volinfo, char **pathlist)
goto out;
}
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
if (uuid_compare (brickinfo->uuid, MY_UUID))
continue;
@ -6400,7 +6409,7 @@ glusterd_recreate_volfiles (glusterd_conf_t *conf)
int op_ret = 0;
GF_ASSERT (conf);
list_for_each_entry (volinfo, &conf->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &conf->volumes, vol_list) {
ret = generate_brick_volfiles (volinfo);
if (ret) {
gf_log ("glusterd", GF_LOG_ERROR, "Failed to "
@ -6800,7 +6809,7 @@ glusterd_friend_contains_vol_bricks (glusterd_volinfo_t *volinfo,
GF_ASSERT (volinfo);
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
if (!uuid_compare (brickinfo->uuid, friend_uuid)) {
count++;
}
@ -6831,8 +6840,8 @@ glusterd_friend_remove_cleanup_vols (uuid_t uuid)
priv = THIS->private;
GF_ASSERT (priv);
list_for_each_entry_safe (volinfo, tmp_volinfo,
&priv->volumes, vol_list) {
cds_list_for_each_entry_safe (volinfo, tmp_volinfo, &priv->volumes,
vol_list) {
if (glusterd_friend_contains_vol_bricks (volinfo, uuid) == 2) {
gf_log (THIS->name, GF_LOG_INFO,
"Deleting stale volume %s", volinfo->volname);
@ -6965,7 +6974,7 @@ glusterd_restart_rebalance (glusterd_conf_t *conf)
int ret = 0;
char op_errstr[256];
list_for_each_entry (volinfo, &conf->volumes, vol_list) {
cds_list_for_each_entry (volinfo, &conf->volumes, vol_list) {
if (!volinfo->rebal.defrag_cmd)
continue;
if (!gd_should_i_start_rebalance (volinfo))
@ -8067,7 +8076,7 @@ glusterd_volume_rebalance_use_rsp_dict (dict_t *aggr, dict_t *rsp_dict)
node_uuid_str = gf_strdup (node_uuid);
/* Finding the index of the node-uuid in the peer-list */
list_for_each_entry (peerinfo, &conf->peers, uuid_list) {
cds_list_for_each_entry (peerinfo, &conf->peers, uuid_list) {
peer_uuid_str = gd_peer_uuid_str (peerinfo);
if (strcmp (peer_uuid_str, node_uuid_str) == 0)
break;
@ -9093,7 +9102,7 @@ gd_should_i_start_rebalance (glusterd_volinfo_t *volinfo) {
switch (volinfo->rebal.op) {
case GD_OP_REBALANCE:
list_for_each_entry (brick, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brick, &volinfo->bricks, brick_list) {
if (uuid_compare (MY_UUID, brick->uuid) == 0) {
retval = _gf_true;
break;
@ -9393,13 +9402,14 @@ glusterd_rpc_clnt_unref (glusterd_conf_t *conf, rpc_clnt_t *rpc)
}
int32_t
glusterd_compare_volume_name(struct list_head *list1, struct list_head *list2)
glusterd_compare_volume_name(struct cds_list_head *list1,
struct cds_list_head *list2)
{
glusterd_volinfo_t *volinfo1 = NULL;
glusterd_volinfo_t *volinfo2 = NULL;
volinfo1 = list_entry(list1, glusterd_volinfo_t, vol_list);
volinfo2 = list_entry(list2, glusterd_volinfo_t, vol_list);
volinfo1 = cds_list_entry (list1, glusterd_volinfo_t, vol_list);
volinfo2 = cds_list_entry (list2, glusterd_volinfo_t, vol_list);
return strcmp(volinfo1->volname, volinfo2->volname);
}
@ -9557,7 +9567,7 @@ glusterd_get_value_for_vme_entry (struct volopt_map_entry *vme, char **def_val)
this = THIS;
GF_ASSERT (this);
INIT_LIST_HEAD (&vol_opt_handle.list);
CDS_INIT_LIST_HEAD (&vol_opt_handle.list);
if (_get_xlator_opt_key_from_vme (vme, &key)) {
gf_log (this->name, GF_LOG_ERROR, "Failed to get %s key from "
@ -9715,7 +9725,7 @@ glusterd_get_volopt_content (dict_t * ctx, gf_boolean_t xml_out)
}
#endif
INIT_LIST_HEAD (&vol_opt_handle.list);
CDS_INIT_LIST_HEAD (&vol_opt_handle.list);
for (vme = &glusterd_volopt_map[0]; vme->key; vme++) {
@ -9863,7 +9873,7 @@ glusterd_have_peers ()
conf = this->private;
GF_ASSERT (conf);
return !list_empty (&conf->peers);
return !cds_list_empty (&conf->peers);
}
void
@ -9880,10 +9890,10 @@ glusterd_op_clear_xaction_peers ()
GF_ASSERT (this);
GF_ASSERT (priv);
list_for_each_entry_safe (peerinfo, tmp, &priv->xaction_peers,
op_peers_list) {
cds_list_for_each_entry_safe (peerinfo, tmp, &priv->xaction_peers,
op_peers_list) {
GF_ASSERT (peerinfo);
list_del_init (&peerinfo->op_peers_list);
cds_list_del_init (&peerinfo->op_peers_list);
}
}
@ -9895,3 +9905,23 @@ glusterd_is_volume_started (glusterd_volinfo_t *volinfo)
return (volinfo->status == GLUSTERD_STATUS_STARTED);
}
/* This function will insert the element to the list in a order.
Order will be based on the compare function provided as a input.
If element to be inserted in ascending order compare should return:
0: if both the arguments are equal
>0: if first argument is greater than second argument
<0: if first argument is less than second argument */
void
glusterd_list_add_order (struct cds_list_head *new, struct cds_list_head *head,
int (*compare)(struct cds_list_head *,
struct cds_list_head *))
{
struct cds_list_head *pos = NULL;
cds_list_for_each_rcu (pos, head) {
if (compare (new, pos) >= 0)
break;
}
cds_list_add_rcu (new, pos);
}

16
xlators/mgmt/glusterd/src/glusterd-utils.h
View File

@ -295,9 +295,9 @@ int
glusterd_sm_tr_log_add_to_dict (dict_t *dict,
glusterd_sm_tr_log_t *circular_log);
int
glusterd_remove_pending_entry (struct list_head *list, void *elem);
glusterd_remove_pending_entry (struct cds_list_head *list, void *elem);
int
glusterd_clear_pending_nodes (struct list_head *list);
glusterd_clear_pending_nodes (struct cds_list_head *list);
int32_t
glusterd_brick_connect (glusterd_volinfo_t *volinfo,
glusterd_brickinfo_t *brickinfo, char *socketpath);
@ -476,7 +476,7 @@ glusterd_do_quorum_action ();
int
glusterd_get_quorum_cluster_counts (xlator_t *this, int *active_count,
int *quorum_count,
struct list_head *peer_list,
struct cds_list_head *peer_list,
gf_boolean_t _local__xaction_peers);
int
@ -488,8 +488,7 @@ glusterd_is_volume_in_server_quorum (glusterd_volinfo_t *volinfo);
gf_boolean_t
glusterd_is_any_volume_in_server_quorum (xlator_t *this);
gf_boolean_t
does_gd_meet_server_quorum (xlator_t *this,
struct list_head *peers_list,
does_gd_meet_server_quorum (xlator_t *this, struct cds_list_head *peers_list,
gf_boolean_t _local__xaction_peers);
int
@ -581,7 +580,7 @@ rpc_clnt_t *
glusterd_rpc_clnt_unref (glusterd_conf_t *conf, rpc_clnt_t *rpc);
int32_t
glusterd_compare_volume_name(struct list_head *, struct list_head *);
glusterd_compare_volume_name(struct cds_list_head *, struct cds_list_head *);
char*
glusterd_get_brick_mount_device (char *brick_path);
@ -689,4 +688,9 @@ glusterd_nfs_pmap_deregister ();
gf_boolean_t
glusterd_is_volume_started (glusterd_volinfo_t *volinfo);
void
glusterd_list_add_order (struct cds_list_head *new, struct cds_list_head *head,
int (*compare)(struct cds_list_head *,
struct cds_list_head *));
#endif

18
xlators/mgmt/glusterd/src/glusterd-volgen.c
View File

@ -80,7 +80,7 @@ xlator_instantiate_va (const char *type, const char *format, va_list arg)
if (!xl->options)
goto error;
xl->name = volname;
INIT_LIST_HEAD (&xl->volume_options);
CDS_INIT_LIST_HEAD (&xl->volume_options);
xl->ctx = THIS->ctx;
@ -2555,7 +2555,7 @@ volgen_graph_build_clients (volgen_graph_t *graph, glusterd_volinfo_t *volinfo,
strcpy (transt, "tcp");
i = 0;
list_for_each_entry (brick, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brick, &volinfo->bricks, brick_list) {
xl = volgen_graph_build_client (graph, volinfo,
brick->hostname, brick->path,
brick->brick_id,
@ -3721,7 +3721,7 @@ build_shd_graph (volgen_graph_t *graph, dict_t *mod_dict)
goto out;
}
list_for_each_entry (voliter, &priv->volumes, vol_list) {
cds_list_for_each_entry (voliter, &priv->volumes, vol_list) {
ret = build_shd_volume_graph (this, graph, voliter, mod_dict,
set_dict, graph_check,
&valid_config);
@ -3782,7 +3782,7 @@ build_nfs_graph (volgen_graph_t *graph, dict_t *mod_dict)
if (ret)
goto out;
list_for_each_entry (voliter, &priv->volumes, vol_list) {
cds_list_for_each_entry (voliter, &priv->volumes, vol_list) {
if (voliter->status != GLUSTERD_STATUS_STARTED)
continue;
@ -3880,7 +3880,7 @@ build_nfs_graph (volgen_graph_t *graph, dict_t *mod_dict)
goto out;
}
list_for_each_entry (voliter, &priv->volumes, vol_list) {
cds_list_for_each_entry (voliter, &priv->volumes, vol_list) {
if (mod_dict) {
ret = volgen_graph_set_options_generic (graph, mod_dict, voliter,
@ -4016,7 +4016,7 @@ build_quotad_graph (volgen_graph_t *graph, dict_t *mod_dict)
goto out;
}
list_for_each_entry (voliter, &priv->volumes, vol_list) {
cds_list_for_each_entry (voliter, &priv->volumes, vol_list) {
if (voliter->status != GLUSTERD_STATUS_STARTED)
continue;
@ -4175,7 +4175,7 @@ generate_brick_volfiles (glusterd_volinfo_t *volinfo)
}
}
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
gf_log (this->name, GF_LOG_DEBUG,
"Found a brick - %s:%s", brickinfo->hostname,
brickinfo->path);
@ -4659,7 +4659,7 @@ glusterd_validate_brickreconf (glusterd_volinfo_t *volinfo,
glusterd_brickinfo_t *brickinfo = NULL;
int ret = -1;
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
gf_log ("", GF_LOG_DEBUG,
"Validating %s", brickinfo->hostname);
@ -4864,7 +4864,7 @@ _gd_get_option_type (char *key)
vmep = _gd_get_vmep (key);
if (vmep) {
INIT_LIST_HEAD (&vol_opt_list.list);
CDS_INIT_LIST_HEAD (&vol_opt_list.list);
ret = xlator_volopt_dynload (vmep->voltype, &dl_handle,
&vol_opt_list);
if (ret)

41
xlators/mgmt/glusterd/src/glusterd-volume-ops.c
View File

@ -113,7 +113,7 @@ glusterd_check_brick_order(dict_t *dict, char *err_str)
ai_list = malloc (sizeof (addrinfo_list_t));
ai_list->info = NULL;
INIT_LIST_HEAD (&ai_list->list);
CDS_INIT_LIST_HEAD (&ai_list->list);
ret = dict_get_str (dict, "volname", &volname);
if (ret) {
@ -189,19 +189,20 @@ glusterd_check_brick_order(dict_t *dict, char *err_str)
goto out;
}
ai_list_tmp1->info = ai_info;
list_add_tail (&ai_list_tmp1->list, &ai_list->list);
cds_list_add_tail (&ai_list_tmp1->list, &ai_list->list);
ai_list_tmp1 = NULL;
}
i = 0;
ai_list_tmp1 = list_entry (ai_list->list.next, addrinfo_list_t, list);
ai_list_tmp1 = cds_list_entry (ai_list->list.next,
addrinfo_list_t, list);
/* Check for bad brick order */
while (i < brick_count) {
++i;
ai_info = ai_list_tmp1->info;
ai_list_tmp1 = list_entry (ai_list_tmp1->list.next,
addrinfo_list_t, list);
ai_list_tmp1 = cds_list_entry (ai_list_tmp1->list.next,
addrinfo_list_t, list);
if (0 == i % sub_count) {
j = 0;
continue;
@ -216,8 +217,8 @@ glusterd_check_brick_order(dict_t *dict, char *err_str)
goto check_failed;
if (GF_AI_COMPARE_MATCH == ret)
goto found_bad_brick_order;
ai_list_tmp2 = list_entry (ai_list_tmp2->list.next,
addrinfo_list_t, list);
ai_list_tmp2 = cds_list_entry (ai_list_tmp2->list.next,
addrinfo_list_t, list);
}
++j;
}
@ -238,7 +239,7 @@ found_bad_brick_order:
out:
ai_list_tmp2 = NULL;
GF_FREE (brick_list_ptr);
list_for_each_entry (ai_list_tmp1, &ai_list->list, list) {
cds_list_for_each_entry (ai_list_tmp1, &ai_list->list, list) {
if (ai_list_tmp1->info)
freeaddrinfo (ai_list_tmp1->info);
free (ai_list_tmp2);
@ -1328,7 +1329,7 @@ glusterd_op_stage_start_volume (dict_t *dict, char **op_errstr,
}
}
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
brick_count++;
ret = glusterd_resolve_brick (brickinfo);
if (ret) {
@ -1585,7 +1586,8 @@ glusterd_op_stage_delete_volume (dict_t *dict, char **op_errstr)
goto out;
}
if (volinfo->snap_count > 0 || !list_empty(&volinfo->snap_volumes)) {
if (volinfo->snap_count > 0 ||
!cds_list_empty (&volinfo->snap_volumes)) {
snprintf (msg, sizeof (msg), "Cannot delete Volume %s ,"
"as it has %"PRIu64" snapshots. "
"To delete the volume, "
@ -2122,7 +2124,7 @@ glusterd_op_create_volume (dict_t *dict, char **op_errstr)
#endif
list_add_tail (&brickinfo->brick_list, &volinfo->bricks);
cds_list_add_tail (&brickinfo->brick_list, &volinfo->bricks);
brick = strtok_r (NULL, " \n", &saveptr);
i++;
}
@ -2159,8 +2161,8 @@ glusterd_op_create_volume (dict_t *dict, char **op_errstr)
}
volinfo->rebal.defrag_status = 0;
list_add_order (&volinfo->vol_list, &priv->volumes,
glusterd_compare_volume_name);
glusterd_list_add_order (&volinfo->vol_list, &priv->volumes,
glusterd_compare_volume_name);
vol_added = _gf_true;
out:
@ -2184,7 +2186,7 @@ glusterd_start_volume (glusterd_volinfo_t *volinfo, int flags,
GF_ASSERT (this);
GF_ASSERT (volinfo);
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
ret = glusterd_brick_start (volinfo, brickinfo, wait);
/* If 'force' try to start all bricks regardless of success or
* failure
@ -2252,7 +2254,8 @@ glusterd_op_start_volume (dict_t *dict, char **op_errstr)
* introduced in gluster-3.6.0
*/
if (conf->op_version >= GD_OP_VERSION_3_6_0) {
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
brick_count++;
/* Don't check bricks that are not owned by you
*/
@ -2308,7 +2311,7 @@ glusterd_stop_volume (glusterd_volinfo_t *volinfo)
GF_VALIDATE_OR_GOTO (this->name, volinfo, out);
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
ret = glusterd_brick_stop (volinfo, brickinfo, _gf_false);
if (ret) {
gf_log (this->name, GF_LOG_ERROR, "Failed to stop "
@ -2471,8 +2474,8 @@ glusterd_op_statedump_volume (dict_t *dict, char **op_errstr)
if (ret)
goto out;
} else {
list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks,
brick_list) {
ret = glusterd_brick_statedump (volinfo, brickinfo,
options, option_cnt,
op_errstr);
@ -2663,7 +2666,7 @@ glusterd_clearlocks_get_local_client_ports (glusterd_volinfo_t *volinfo,
priv = THIS->private;
index = -1;
list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) {
index++;
if (uuid_compare (brickinfo->uuid, MY_UUID))
continue;

16
xlators/mgmt/glusterd/src/glusterd.c
View File

@ -969,7 +969,7 @@ _install_mount_spec (dict_t *opts, char *key, data_t *value, void *data)
} else if (parse_mount_pattern_desc (mspec, pdesc) != 0)
goto err;
list_add_tail (&mspec->speclist, &priv->mount_specs);
cds_list_add_tail (&mspec->speclist, &priv->mount_specs);
return 0;
err:
@ -1507,11 +1507,11 @@ init (xlator_t *this)
gf_gld_mt_glusterd_conf_t);
GF_VALIDATE_OR_GOTO(this->name, conf, out);
INIT_LIST_HEAD (&conf->peers);
INIT_LIST_HEAD (&conf->xaction_peers);
INIT_LIST_HEAD (&conf->volumes);
INIT_LIST_HEAD (&conf->snapshots);
INIT_LIST_HEAD (&conf->missed_snaps_list);
CDS_INIT_LIST_HEAD (&conf->peers);
CDS_INIT_LIST_HEAD (&conf->xaction_peers);
CDS_INIT_LIST_HEAD (&conf->volumes);
CDS_INIT_LIST_HEAD (&conf->snapshots);
CDS_INIT_LIST_HEAD (&conf->missed_snaps_list);
pthread_mutex_init (&conf->mutex, NULL);
conf->rpc = rpc;
@ -1567,7 +1567,7 @@ init (xlator_t *this)
}
}
INIT_LIST_HEAD (&conf->mount_specs);
CDS_INIT_LIST_HEAD (&conf->mount_specs);
ret = dict_foreach (this->options, _install_mount_spec, NULL);
if (ret)
@ -1613,7 +1613,7 @@ init (xlator_t *this)
* spawn process/bricks that may need (re)starting since last
* time (this) glusterd was up.*/
if (list_empty (&conf->peers)) {
if (cds_list_empty (&conf->peers)) {
glusterd_launch_synctask (glusterd_spawn_daemons, NULL);
}
ret = glusterd_options_init (this);

38
xlators/mgmt/glusterd/src/glusterd.h
View File

@ -127,8 +127,8 @@ struct glusterd_volgen {
typedef struct {
struct _volfile_ctx *volfile;
pthread_mutex_t mutex;
struct list_head peers;
struct list_head xaction_peers;
struct cds_list_head peers;
struct cds_list_head xaction_peers;
gf_boolean_t verify_volfile_checksum;
gf_boolean_t trace;
uuid_t uuid;
@ -138,8 +138,8 @@ typedef struct {
glusterd_svc_t nfs_svc;
glusterd_svc_t quotad_svc;
struct pmap_registry *pmap;
struct list_head volumes;
struct list_head snapshots; /*List of snap volumes */
struct cds_list_head volumes;
struct cds_list_head snapshots; /*List of snap volumes */
pthread_mutex_t xprt_lock;
struct list_head xprt_list;
gf_store_handle_t *handle;
@ -155,7 +155,7 @@ typedef struct {
* cluster with no
* transaction ids */
struct list_head mount_specs;
struct cds_list_head mount_specs;
gf_boolean_t valgrind;
pthread_t brick_thread;
void *hooks_priv;
@ -171,7 +171,7 @@ typedef struct {
uint32_t base_port;
char *snap_bricks_directory;
gf_store_handle_t *missed_snaps_list_shandle;
struct list_head missed_snaps_list;
struct cds_list_head missed_snaps_list;
int ping_timeout;
} glusterd_conf_t;
@ -189,7 +189,7 @@ struct glusterd_brickinfo {
char brick_id[1024];/*Client xlator name, AFR changelog name*/
char fstype [NAME_MAX]; /* Brick file-system type */
char mnt_opts [1024]; /* Brick mount options */
struct list_head brick_list;
struct cds_list_head brick_list;
uuid_t uuid;
int port;
int rdma_port;
@ -313,17 +313,17 @@ struct glusterd_volinfo_ {
int brick_count;
uint64_t snap_count;
uint64_t snap_max_hard_limit;
struct list_head vol_list;
struct cds_list_head vol_list;
/* In case of a snap volume
i.e (is_snap_volume == TRUE) this
is linked to glusterd_snap_t->volumes.
In case of a non-snap volume, this is
linked to glusterd_conf_t->volumes */
struct list_head snapvol_list;
struct cds_list_head snapvol_list;
/* This is a current pointer for
glusterd_volinfo_t->snap_volumes */
struct list_head bricks;
struct list_head snap_volumes;
struct cds_list_head bricks;
struct cds_list_head snap_volumes;
/* TODO : Need to remove this, as this
* is already part of snapshot object.
*/
@ -390,8 +390,8 @@ typedef enum gd_snap_status_ {
struct glusterd_snap_ {
gf_lock_t lock;
struct list_head volumes;
struct list_head snap_list;
struct cds_list_head volumes;
struct cds_list_head snap_list;
char snapname[GLUSTERD_MAX_SNAP_NAME];
uuid_t snap_id;
char *description;
@ -407,14 +407,14 @@ typedef struct glusterd_snap_op_ {
char *brick_path;
int32_t op;
int32_t status;
struct list_head snap_ops_list;
struct cds_list_head snap_ops_list;
} glusterd_snap_op_t;
typedef struct glusterd_missed_snap_ {
char *node_uuid;
char *snap_uuid;
struct list_head missed_snaps;
struct list_head snap_ops;
struct cds_list_head missed_snaps;
struct cds_list_head snap_ops;
} glusterd_missed_snap_info;
typedef enum gd_node_type_ {
@ -434,7 +434,7 @@ typedef enum missed_snap_stat {
} missed_snap_stat;
typedef struct glusterd_pending_node_ {
struct list_head list;
struct cds_list_head list;
void *node;
gd_node_type type;
int32_t index;
@ -459,7 +459,7 @@ enum glusterd_vol_comp_status_ {
};
typedef struct addrinfo_list {
struct list_head list;
struct cds_list_head list;
struct addrinfo *info;
} addrinfo_list_t;
@ -629,7 +629,7 @@ typedef ssize_t (*gd_serialize_t) (struct iovec outmsg, void *args);
snprintf (key, sizeof (key), \
"glusterd.xaction_peer"); \
\
list_for_each_entry (_peerinfo, head, member) { \
cds_list_for_each_entry (_peerinfo, head, member) { \
glusterd_dump_peer (_peerinfo, key, index, xpeers); \
if (!xpeers) \
glusterd_dump_peer_rpcstat (_peerinfo, key, \