glusterfs

1
/*
2
  Copyright (c) 2008-2012 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 <sys/uio.h>
12

13
#include "glusterfs/common-utils.h"
14
#include "glusterfs/xlator.h"
15
#include "glusterfs/graph-utils.h"
16
#include "glusterfs/libglusterfs-messages.h"
17

18
struct gf_printer {
19
    ssize_t (*write)(struct gf_printer *gp, char *buf, size_t len);
20
    void *priv;
21
    int len;
22
};
23

24
static ssize_t
25
gp_write_file(struct gf_printer *gp, char *buf, size_t len)
26
{
27
    FILE *f = gp->priv;
28

29
    if (fwrite(buf, len, 1, f) != 1) {
30
        gf_msg("graph-print", GF_LOG_ERROR, errno, LG_MSG_FWRITE_FAILED,
31
               "fwrite failed");
32

33
        return -1;
34
    }
35

36
    return len;
37
}
38

39
static int
40
gpprintf(struct gf_printer *gp, const char *format, ...)
41
{
42
    va_list arg;
43
    char *str = NULL;
44
    int ret = 0;
45

46
    va_start(arg, format);
47
    ret = gf_vasprintf(&str, format, arg);
48
    va_end(arg);
49

50
    if (ret < 0)
51
        return ret;
52

53
    ret = gp->write(gp, str, ret);
54

55
    GF_FREE(str);
56

57
    return ret;
58
}
59

60
#define GPPRINTF(gp, fmt, ...)                                                 \
61
    do {                                                                       \
62
        ret = gpprintf(gp, fmt, ##__VA_ARGS__);                                \
63
        if (ret == -1)                                                         \
64
            goto out;                                                          \
65
        else                                                                   \
66
            gp->len += ret;                                                    \
67
    } while (0)
68

69
static int
70
_print_volume_options(dict_t *d, char *k, data_t *v, void *tmp)
71
{
72
    struct gf_printer *gp = tmp;
73
    int ret = 0;
74
    GPPRINTF(gp, "    option %s %s\n", k, v->data);
75
    return 0;
76
out:
77
    /* means, it is a failure */
78
    return -1;
79
}
80

81
static int
82
glusterfs_graph_print(struct gf_printer *gp, glusterfs_graph_t *graph)
83
{
84
    xlator_t *trav = NULL;
85
    xlator_list_t *xch = NULL;
86
    int ret = 0;
87
    ssize_t len = 0;
88

89
    if (!graph->first)
90
        return 0;
91

92
    for (trav = graph->first; trav->next; trav = trav->next)
93
        ;
94
    for (; trav; trav = trav->prev) {
95
        GPPRINTF(gp, "volume %s\n    type %s\n", trav->name, trav->type);
96

97
        ret = dict_foreach(trav->options, _print_volume_options, gp);
98
        if (ret)
99
            goto out;
100

101
        if (trav->children) {
102
            GPPRINTF(gp, "    subvolumes");
103

104
            for (xch = trav->children; xch; xch = xch->next)
105
                GPPRINTF(gp, " %s", xch->xlator->name);
106

107
            GPPRINTF(gp, "\n");
108
        }
109

110
        GPPRINTF(gp, "end-volume\n");
111
        if (trav != graph->first)
112
            GPPRINTF(gp, "\n");
113
    }
114

115
out:
116
    len = gp->len;
117
    if (ret == -1) {
118
        gf_msg("graph-print", GF_LOG_ERROR, 0, LG_MSG_PRINT_FAILED,
119
               "printing failed");
120

121
        return -1;
122
    }
123

124
    return len;
125

126
#undef GPPRINTF
127
}
128

129
int
130
glusterfs_graph_print_file(FILE *file, glusterfs_graph_t *graph)
131
{
132
    struct gf_printer gp = {.write = gp_write_file, .priv = file};
133

134
    return glusterfs_graph_print(&gp, graph);
135
}
136