/
zOMGdev
/
glusterfs
GigaCode
beta
ОбзорЦентр заботыВойти

glusterfs

Форк
0
Ветки: 49Коммиты: 16797Теги: 580
glusterfs
/xlators
/mgmt
/glusterd
/src
/
glusterd-statedump.c 
260 строк · 9.4 Кб
1
/*
2
   Copyright (c) 2014 Red Hat, Inc. <http://www.redhat.com>
3
   This file is part of GlusterFS.
4


5
   This file is licensed to you under your choice of the GNU Lesser
6
   General Public License, version 3 or any later version (LGPLv3 or
7
   later), or the GNU General Public License, version 2 (GPLv2), in all
8
   cases as published by the Free Software Foundation.
9
*/
10


11
#include <glusterfs/statedump.h>
12
#include "glusterd.h"
13
#include "glusterd-shd-svc.h"
14
#include "glusterd-quotad-svc.h"
15
#include "glusterd-locks.h"
16
#include "glusterd-messages.h"
17


18
#define GLUSTERD_DUMP_PEERS(head, member, xpeers)                              \
19
    do {                                                                       \
20
        glusterd_peerinfo_t *_peerinfo = NULL;                                 \
21
        int index = 1;                                                         \
22
        char *key = NULL;                                                      \
23
                                                                               \
24
        key = xpeers ? "glusterd.xaction_peer" : "glusterd.peer";              \
25
                                                                               \
26
        RCU_READ_LOCK;                                                         \
27
        cds_list_for_each_entry_rcu(_peerinfo, head, member)                   \
28
        {                                                                      \
29
            glusterd_dump_peer(_peerinfo, key, index, xpeers);                 \
30
            if (!xpeers)                                                       \
31
                glusterd_dump_peer_rpcstat(_peerinfo, key, index);             \
32
            index++;                                                           \
33
        }                                                                      \
34
        RCU_READ_UNLOCK;                                                       \
35
                                                                               \
36
    } while (0)
37


38
static void
39
glusterd_dump_peer(glusterd_peerinfo_t *peerinfo, char *input_key, int index,
40
                   gf_boolean_t xpeers)
41
{
42
    char subkey[GF_DUMP_MAX_BUF_LEN + 11] = "";
43
    char key[GF_DUMP_MAX_BUF_LEN] = "";
44


45
    strncpy(key, input_key, sizeof(key) - 1);
46


47
    snprintf(subkey, sizeof(subkey), "%s%d", key, index);
48


49
    gf_proc_dump_build_key(key, subkey, "uuid");
50
    gf_proc_dump_write(key, "%s", uuid_utoa(peerinfo->uuid));
51


52
    gf_proc_dump_build_key(key, subkey, "hostname");
53
    gf_proc_dump_write(key, "%s", peerinfo->hostname);
54


55
    gf_proc_dump_build_key(key, subkey, "port");
56
    gf_proc_dump_write(key, "%d", peerinfo->port);
57


58
    gf_proc_dump_build_key(key, subkey, "state");
59
    gf_proc_dump_write(key, "%d", peerinfo->state);
60


61
    gf_proc_dump_build_key(key, subkey, "quorum-action");
62
    gf_proc_dump_write(key, "%d", peerinfo->quorum_action);
63


64
    gf_proc_dump_build_key(key, subkey, "quorum-contrib");
65
    gf_proc_dump_write(key, "%d", peerinfo->quorum_contrib);
66


67
    gf_proc_dump_build_key(key, subkey, "detaching");
68
    gf_proc_dump_write(key, "%d", peerinfo->detaching);
69


70
    gf_proc_dump_build_key(key, subkey, "locked");
71
    gf_proc_dump_write(key, "%d", peerinfo->locked);
72
}
73


74
static void
75
glusterd_dump_peer_rpcstat(glusterd_peerinfo_t *peerinfo, char *input_key,
76
                           int index)
77
{
78
    rpc_clnt_connection_t *conn = NULL;
79
    int ret = -1;
80
    rpc_clnt_t *rpc = NULL;
81
    char rpcsvc_peername[RPCSVC_PEER_STRLEN] = "";
82
    char subkey[GF_DUMP_MAX_BUF_LEN + 11] = "";
83
    char key[GF_DUMP_MAX_BUF_LEN] = "";
84


85
    strncpy(key, input_key, sizeof(key) - 1);
86


87
    /* Dump the rpc connection statistics */
88
    rpc = peerinfo->rpc;
89
    if (rpc) {
90
        conn = &rpc->conn;
91
        snprintf(subkey, sizeof(subkey), "%s%d", key, index);
92
        ret = rpcsvc_transport_peername(conn->trans, (char *)&rpcsvc_peername,
93
                                        sizeof(rpcsvc_peername));
94
        if (!ret) {
95
            gf_proc_dump_build_key(key, subkey, "rpc.peername");
96
            gf_proc_dump_write(key, "%s", rpcsvc_peername);
97
        }
98
        gf_proc_dump_build_key(key, subkey, "rpc.connected");
99
        gf_proc_dump_write(key, "%d", (conn->status == RPC_STATUS_CONNECTED));
100


101
        gf_proc_dump_build_key(key, subkey, "rpc.total-bytes-read");
102
        gf_proc_dump_write(key, "%" PRIu64, conn->trans->total_bytes_read);
103


104
        gf_proc_dump_build_key(key, subkey, "rpc.total-bytes-written");
105
        gf_proc_dump_write(key, "%" PRIu64, conn->trans->total_bytes_write);
106


107
        gf_proc_dump_build_key(key, subkey, "rpc.ping_msgs_sent");
108
        gf_proc_dump_write(key, "%" PRIu64, conn->pingcnt);
109


110
        gf_proc_dump_build_key(key, subkey, "rpc.msgs_sent");
111
        gf_proc_dump_write(key, "%" PRIu64, conn->msgcnt);
112
    }
113
}
114


115
static void
116
glusterd_dump_client_details(glusterd_conf_t *conf)
117
{
118
    rpc_transport_t *xprt = NULL;
119
    char key[GF_DUMP_MAX_BUF_LEN] = "";
120
    char subkey[50] = "";
121
    int index = 1;
122


123
    pthread_mutex_lock(&conf->xprt_lock);
124
    {
125
        list_for_each_entry(xprt, &conf->xprt_list, list)
126
        {
127
            snprintf(subkey, sizeof(subkey), "glusterd.client%d", index);
128


129
            gf_proc_dump_build_key(key, subkey, "identifier");
130
            gf_proc_dump_write(key, "%s", xprt->peerinfo.identifier);
131


132
            gf_proc_dump_build_key(key, subkey, "volname");
133
            gf_proc_dump_write(key, "%s", xprt->peerinfo.volname);
134


135
            gf_proc_dump_build_key(key, subkey, "max-op-version");
136
            gf_proc_dump_write(key, "%u", xprt->peerinfo.max_op_version);
137


138
            gf_proc_dump_build_key(key, subkey, "min-op-version");
139
            gf_proc_dump_write(key, "%u", xprt->peerinfo.min_op_version);
140
            index++;
141
        }
142
    }
143
    pthread_mutex_unlock(&conf->xprt_lock);
144
}
145


146
/* The following function is just for dumping mgmt_v3_lock dictionary, any other
147
 * dict passed to this API will not work */
148


149
static void
150
glusterd_dict_mgmt_v3_lock_statedump(dict_t *dict)
151
{
152
    int ret = 0;
153
    int dumplen = 0;
154
    data_pair_t *trav = NULL;
155
    char key[GF_DUMP_MAX_BUF_LEN] = "";
156
    char dump[64 * 1024] = "";
157


158
    if (!dict) {
159
        gf_msg_callingfn("glusterd", GF_LOG_WARNING, EINVAL, GD_MSG_DICT_EMPTY,
160
                         "dict NULL");
161
        goto out;
162
    }
163
    for (trav = dict->members_list; trav; trav = trav->next) {
164
        if (strstr(trav->key, "debug.last-success-bt") != NULL) {
165
            ret = snprintf(&dump[dumplen], sizeof(dump) - dumplen, "\n\t%s:%s",
166
                           trav->key, trav->value->data);
167
        } else {
168
            ret = snprintf(
169
                &dump[dumplen], sizeof(dump) - dumplen, "\n\t%s:%s", trav->key,
170
                uuid_utoa(((glusterd_mgmt_v3_lock_obj *)(trav->value->data))
171
                              ->lock_owner));
172
        }
173
        if ((ret == -1) || !ret)
174
            return;
175
        dumplen += ret;
176
    }
177


178
    if (dumplen) {
179
        gf_proc_dump_build_key(key, "glusterd", "mgmt_v3_lock");
180
        gf_proc_dump_write(key, "%s", dump);
181
    }
182


183
out:
184
    return;
185
}
186


187
int
188
glusterd_dump_priv(xlator_t *this)
189
{
190
    glusterd_conf_t *priv = NULL;
191
    struct pmap_registry *pmap = NULL;
192
    struct pmap_ports *tmp_port = NULL;
193
    char key[GF_DUMP_MAX_BUF_LEN] = "";
194


195
    priv = this->private;
196
    if (!priv)
197
        return 0;
198


199
    pmap = priv->pmap;
200


201
    gf_proc_dump_build_key(key, "xlator.glusterd", "priv");
202
    gf_proc_dump_add_section("%s", key);
203


204
    pthread_mutex_lock(&priv->mutex);
205
    {
206
        gf_proc_dump_build_key(key, "glusterd", "my-uuid");
207
        gf_proc_dump_write(key, "%s", uuid_utoa(priv->uuid));
208


209
        gf_proc_dump_build_key(key, "glusterd", "working-directory");
210
        gf_proc_dump_write(key, "%s", priv->workdir);
211


212
        gf_proc_dump_build_key(key, "glusterd", "max-op-version");
213
        gf_proc_dump_write(key, "%d", GD_OP_VERSION_MAX);
214


215
        gf_proc_dump_build_key(key, "glusterd", "min-op-version");
216
        gf_proc_dump_write(key, "%d", GD_OP_VERSION_MIN);
217


218
        gf_proc_dump_build_key(key, "glusterd", "current-op-version");
219
        gf_proc_dump_write(key, "%d", priv->op_version);
220


221
        gf_proc_dump_build_key(key, "glusterd", "ping-timeout");
222
        gf_proc_dump_write(key, "%ld", priv->ping_timeout);
223
#ifdef BUILD_GNFS
224
        gf_proc_dump_build_key(key, "glusterd", "nfs.online");
225
        gf_proc_dump_write(key, "%d", priv->nfs_svc.online);
226
#endif
227
        gf_proc_dump_build_key(key, "glusterd", "quotad.online");
228
        gf_proc_dump_write(key, "%d", priv->quotad_svc.online);
229


230
        gf_proc_dump_build_key(key, "glusterd", "bitd.online");
231
        gf_proc_dump_write(key, "%d", priv->bitd_svc.online);
232


233
        gf_proc_dump_build_key(key, "glusterd", "scrub.online");
234
        gf_proc_dump_write(key, "%d", priv->scrub_svc.online);
235


236
        /* Dump peer details */
237
        GLUSTERD_DUMP_PEERS(&priv->peers, uuid_list, _gf_false);
238


239
        if (pmap) {
240
            /* Dump brick name and port associated with it */
241
            cds_list_for_each_entry(tmp_port, &pmap->ports, port_list)
242
            {
243
                gf_proc_dump_build_key(key, "glusterd", "brick_port");
244
                gf_proc_dump_write(key, "%d", tmp_port->port);
245
                gf_proc_dump_build_key(key, "glusterd", "brickname");
246
                gf_proc_dump_write(key, "%s", tmp_port->brickname);
247
            }
248
        }
249


250
        /* Dump client details */
251
        glusterd_dump_client_details(priv);
252


253
        /* Dump mgmt_v3_lock from the dictionary if any */
254
        glusterd_dict_mgmt_v3_lock_statedump(priv->mgmt_v3_lock);
255
        dict_dump_to_statedump(priv->opts, "options", "glusterd");
256
    }
257
    pthread_mutex_unlock(&priv->mutex);
258


259
    return 0;
260
}
261

Использование cookies

Мы используем файлы cookie в соответствии с Политикой конфиденциальности и Политикой использования cookies.

Нажимая кнопку «Принимаю», Вы даете АО «СберТех» согласие на обработку Ваших персональных данных в целях совершенствования нашего веб-сайта и Сервиса GitVerse, а также повышения удобства их использования.

Запретить использование cookies Вы можете самостоятельно в настройках Вашего браузера.