Debian Codegraph @

src/network/networkd-varlink-metrics.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include "sd-json.h"
4 #include "sd-varlink.h"
5
6 #include "alloc-util.h"
7 #include "argv-util.h"
8 #include "errno-util.h"
9 #include "fd-util.h"
10 #include "hashmap.h"
11 #include "metrics.h"
12 #include "network-util.h"
13 #include "networkd-link.h"
14 #include "networkd-manager.h"
15 #include "networkd-varlink-metrics.h"
16
17 #define METRIC_IO_SYSTEMD_NETWORK_PREFIX "io.systemd.Network."
18
19 typedef const char* (*link_metric_extractor_t)(const Link *link);
20
21 static int link_metric_build_json(
22 const MetricFamily *mf,
23 sd_varlink *vl,
24 link_metric_extractor_t extractor,
25 void *userdata) {
26
27 Manager *manager = ASSERT_PTR(userdata);
28 Link *link;
29 int r;
30
31 assert(mf && mf->name);
32 assert(vl);
33 assert(extractor);
34
35 HASHMAP_FOREACH(link, manager->links_by_index) {
36 r = metric_build_send_string(mf, vl, link->ifname, extractor(link), /* fields= */ NULL);
37 if (r < 0)
38 return r;
39 }
40
41 return 0;
42 }
43
44 static const char* link_get_address_state(const Link *l) {
45 return link_address_state_to_string(ASSERT_PTR(l)->address_state);
46 }
47
48 static const char* link_get_admin_state(const Link *l) {
49 return link_state_to_string(ASSERT_PTR(l)->state);
50 }
51
52 static const char* link_get_carrier_state(const Link *l) {
53 return link_carrier_state_to_string(ASSERT_PTR(l)->carrier_state);
54 }
55
56 static const char* link_get_ipv4_address_state(const Link *l) {
57 return link_address_state_to_string(ASSERT_PTR(l)->ipv4_address_state);
58 }
59
60 static const char* link_get_ipv6_address_state(const Link *l) {
61 return link_address_state_to_string(ASSERT_PTR(l)->ipv6_address_state);
62 }
63
64 static const char* link_get_oper_state(const Link *l) {
65 return link_operstate_to_string(ASSERT_PTR(l)->operstate);
66 }
67
68 static int link_address_state_build_json(const MetricFamily *mf, sd_varlink *vl, void *userdata) {
69 return link_metric_build_json(mf, vl, link_get_address_state, userdata);
70 }
71
72 static int link_admin_state_build_json(const MetricFamily *mf, sd_varlink *vl, void *userdata) {
73 return link_metric_build_json(mf, vl, link_get_admin_state, userdata);
74 }
75
76 static int link_carrier_state_build_json(const MetricFamily *mf, sd_varlink *vl, void *userdata) {
77 return link_metric_build_json(mf, vl, link_get_carrier_state, userdata);
78 }
79
80 static int link_ipv4_address_state_build_json(const MetricFamily *mf, sd_varlink *vl, void *userdata) {
81 return link_metric_build_json(mf, vl, link_get_ipv4_address_state, userdata);
82 }
83
84 static int link_ipv6_address_state_build_json(const MetricFamily *mf, sd_varlink *vl, void *userdata) {
85 return link_metric_build_json(mf, vl, link_get_ipv6_address_state, userdata);
86 }
87
88 static int link_oper_state_build_json(const MetricFamily *mf, sd_varlink *vl, void *userdata) {
89 return link_metric_build_json(mf, vl, link_get_oper_state, userdata);
90 }
91
92 static int managed_interfaces_build_json(const MetricFamily *mf, sd_varlink *vl, void *userdata) {
93 Manager *manager = ASSERT_PTR(userdata);
94 Link *link;
95 uint64_t count = 0;
96
97 assert(mf && mf->name);
98 assert(vl);
99
100 HASHMAP_FOREACH(link, manager->links_by_index)
101 if (link->network)
102 count++;
103
104 return metric_build_send_unsigned(mf, vl, /* object= */ NULL, count, /* fields= */ NULL);
105 }
106
107 static int required_for_online_build_json(const MetricFamily *mf, sd_varlink *vl, void *userdata) {
108 Manager *manager = ASSERT_PTR(userdata);
109 Link *link;
110 int r;
111
112 assert(mf && mf->name);
113 assert(vl);
114
115 HASHMAP_FOREACH(link, manager->links_by_index) {
116 if (!link->network)
117 continue;
118
119 if (link->network->required_for_online == 0) {
120 r = metric_build_send_string(
121 mf,
122 vl,
123 link->ifname,
124 "no",
125 /* fields= */ NULL);
126 } else {
127 LinkOperationalStateRange range;
128 link_required_operstate_for_online(link, &range);
129
130 const char *min_str = link_operstate_to_string(range.min);
131 const char *max_str = link_operstate_to_string(range.max);
132
133 if (range.min == range.max)
134 r = metric_build_send_string(
135 mf,
136 vl,
137 link->ifname,
138 min_str,
139 /* fields= */ NULL);
140 else {
141 _cleanup_free_ char *value = NULL;
142 if (asprintf(&value, "%s:%s", min_str, max_str) < 0)
143 return -ENOMEM;
144
145 r = metric_build_send_string(
146 mf,
147 vl,
148 link->ifname,
149 value,
150 /* fields= */ NULL);
151 }
152 }
153 if (r < 0)
154 return r;
155 }
156
157 return 0;
158 }
159
160 /* Keep metrics ordered alphabetically */
161 static const MetricFamily network_metric_family_table[] = {
162 {
163 .name = METRIC_IO_SYSTEMD_NETWORK_PREFIX "AddressState",
164 .description = "Per interface metric: address state",
165 .type = METRIC_FAMILY_TYPE_STRING,
166 .generate = link_address_state_build_json,
167 },
168 {
169 .name = METRIC_IO_SYSTEMD_NETWORK_PREFIX "AdministrativeState",
170 .description = "Per interface metric: administrative state",
171 .type = METRIC_FAMILY_TYPE_STRING,
172 .generate = link_admin_state_build_json,
173 },
174 {
175 .name = METRIC_IO_SYSTEMD_NETWORK_PREFIX "CarrierState",
176 .description = "Per interface metric: carrier state",
177 .type = METRIC_FAMILY_TYPE_STRING,
178 .generate = link_carrier_state_build_json,
179 },
180 {
181 .name = METRIC_IO_SYSTEMD_NETWORK_PREFIX "IPv4AddressState",
182 .description = "Per interface metric: IPv4 address state",
183 .type = METRIC_FAMILY_TYPE_STRING,
184 .generate = link_ipv4_address_state_build_json,
185 },
186 {
187 .name = METRIC_IO_SYSTEMD_NETWORK_PREFIX "IPv6AddressState",
188 .description = "Per interface metric: IPv6 address state",
189 .type = METRIC_FAMILY_TYPE_STRING,
190 .generate = link_ipv6_address_state_build_json,
191 },
192 {
193 .name = METRIC_IO_SYSTEMD_NETWORK_PREFIX "ManagedInterfaces",
194 .description = "Number of network interfaces managed by systemd-networkd",
195 .type = METRIC_FAMILY_TYPE_GAUGE,
196 .generate = managed_interfaces_build_json,
197 },
198 {
199 .name = METRIC_IO_SYSTEMD_NETWORK_PREFIX "OperationalState",
200 .description = "Per interface metric: operational state",
201 .type = METRIC_FAMILY_TYPE_STRING,
202 .generate = link_oper_state_build_json,
203 },
204 {
205 .name = METRIC_IO_SYSTEMD_NETWORK_PREFIX "RequiredForOnline",
206 .description = "Per interface metric: required operational state for online, or 'no' if not required",
207 .type = METRIC_FAMILY_TYPE_STRING,
208 .generate = required_for_online_build_json,
209 },
210 {}
211 };
212
213 static int vl_method_metrics_describe(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
214 return metrics_method_describe(network_metric_family_table, link, parameters, flags, userdata);
215 }
216
217 static int vl_method_metrics_list(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
218 return metrics_method_list(network_metric_family_table, link, parameters, flags, userdata);
219 }
220
221 int manager_varlink_metrics_init(Manager *m, int fd) {
222 _unused_ _cleanup_close_ int fd_close = fd; /* take possession */
223 int r;
224
225 assert(m);
226
227 if (m->varlink_metrics_server)
228 return 0;
229
230 if (fd < 0 && invoked_by_systemd()) {
231 log_debug("systemd-networkd-varlink-metrics.socket seems to be disabled, not installing metrics varlink server.");
232 return 0;
233 }
234
235 _cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
236 r = metrics_setup_varlink_server(
237 &s,
238 SD_VARLINK_SERVER_INHERIT_USERDATA,
239 m->event,
240 SD_EVENT_PRIORITY_NORMAL,
241 vl_method_metrics_list,
242 vl_method_metrics_describe,
243 m);
244 if (r < 0)
245 return log_error_errno(r, "Failed to set up metrics varlink server: %m");
246
247 if (fd < 0) {
248 r = sd_varlink_server_listen_address(
249 s,
250 "/run/systemd/report/io.systemd.Network",
251 0666 | SD_VARLINK_SERVER_MODE_MKDIR_0755);
252 if (ERRNO_IS_NEG_PRIVILEGE(r)) {
253 log_warning_errno(r, "Failed to bind to metrics varlink socket, ignoring: %m");
254 return 0;
255 }
256 } else
257 r = sd_varlink_server_listen_fd(s, fd);
258 if (r < 0)
259 return log_error_errno(r, "Failed to bind to metrics varlink socket: %m");
260
261 TAKE_FD(fd_close);
262 m->varlink_metrics_server = TAKE_PTR(s);
263 return 0;
264 }