2 * collectd - src/ipvs.c (based on ipvsadm and libipvs)
3 * Copyright (C) 1997 Steven Clarke <steven@monmouth.demon.co.uk>
4 * Copyright (C) 1998-2004 Wensong Zhang <wensong@linuxvirtualserver.org>
5 * Copyright (C) 2003-2004 Peter Kese <peter.kese@ijs.si>
6 * Copyright (C) 2007 Sebastian Harl
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; only version 2 of the License is applicable.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 * Sebastian Harl <sh at tokkee.org>
26 * This plugin collects statistics about IPVS connections. It requires Linux
29 * See http://www.linuxvirtualserver.org/software/index.html for more
30 * information about IPVS.
38 # include <arpa/inet.h>
39 #endif /* HAVE_ARPA_INET_H */
41 # include <netinet/in.h>
42 #endif /* HAVE_NETINET_IN_H */
44 /* this can probably only be found in the kernel sources */
45 #if HAVE_LINUX_IP_VS_H
46 # include <linux/ip_vs.h>
47 #elif HAVE_NET_IP_VS_H
48 # include <net/ip_vs.h>
51 #endif /* HAVE_IP_VS_H */
53 #define log_err(...) ERROR ("ipvs: " __VA_ARGS__)
54 #define log_info(...) INFO ("ipvs: " __VA_ARGS__)
59 static int sockfd = -1;
64 static struct ip_vs_get_services *ipvs_get_services (void)
66 struct ip_vs_getinfo ipvs_info;
67 struct ip_vs_get_services *ret;
71 len = sizeof (ipvs_info);
73 if (0 != getsockopt (sockfd, IPPROTO_IP, IP_VS_SO_GET_INFO,
74 (void *)&ipvs_info, &len)) {
76 log_err ("ip_vs_get_services: getsockopt() failed: %s",
77 sstrerror (errno, errbuf, sizeof (errbuf)));
82 sizeof (struct ip_vs_service_entry) * ipvs_info.num_services;
84 if (NULL == (ret = malloc (len))) {
85 log_err ("ipvs_get_services: Out of memory.");
89 ret->num_services = ipvs_info.num_services;
91 if (0 != getsockopt (sockfd, IPPROTO_IP, IP_VS_SO_GET_SERVICES,
94 log_err ("ipvs_get_services: getsockopt failed: %s",
95 sstrerror (errno, errbuf, sizeof (errbuf)));
101 } /* ipvs_get_services */
103 static struct ip_vs_get_dests *ipvs_get_dests (struct ip_vs_service_entry *se)
105 struct ip_vs_get_dests *ret;
108 len = sizeof (*ret) + sizeof (struct ip_vs_dest_entry) * se->num_dests;
110 if (NULL == (ret = malloc (len))) {
111 log_err ("ipvs_get_dests: Out of memory.");
115 ret->fwmark = se->fwmark;
116 ret->protocol = se->protocol;
117 ret->addr = se->addr;
118 ret->port = se->port;
119 ret->num_dests = se->num_dests;
121 if (0 != getsockopt (sockfd, IPPROTO_IP, IP_VS_SO_GET_DESTS,
122 (void *)ret, &len)) {
124 log_err ("ipvs_get_dests: getsockopt() failed: %s",
125 sstrerror (errno, errbuf, sizeof (errbuf)));
130 } /* ip_vs_get_dests */
133 * collectd plugin API and helper functions
135 static int cipvs_init (void)
137 struct ip_vs_getinfo ipvs_info;
141 if (-1 == (sockfd = socket (AF_INET, SOCK_RAW, IPPROTO_RAW))) {
143 log_err ("cipvs_init: socket() failed: %s",
144 sstrerror (errno, errbuf, sizeof (errbuf)));
148 len = sizeof (ipvs_info);
150 if (0 != getsockopt (sockfd, IPPROTO_IP, IP_VS_SO_GET_INFO,
151 (void *)&ipvs_info, &len)) {
153 log_err ("cipvs_init: getsockopt() failed: %s",
154 sstrerror (errno, errbuf, sizeof (errbuf)));
160 /* we need IPVS >= 1.1.4 */
161 if (ipvs_info.version < ((1 << 16) + (1 << 8) + 4)) {
162 log_err ("cipvs_init: IPVS version too old (%d.%d.%d < %d.%d.%d)",
163 NVERSION (ipvs_info.version), 1, 1, 4);
169 log_info ("Successfully connected to IPVS %d.%d.%d",
170 NVERSION (ipvs_info.version));
176 * ipvs-<virtual IP>_{UDP,TCP}<port>/<type>-total
177 * ipvs-<virtual IP>_{UDP,TCP}<port>/<type>-<real IP>_<port>
180 /* plugin instance */
181 static int get_pi (struct ip_vs_service_entry *se, char *pi, size_t size)
186 if ((NULL == se) || (NULL == pi))
189 addr.s_addr = se->addr;
191 /* inet_ntoa() returns a pointer to a statically allocated buffer
192 * I hope non-glibc systems behave the same */
193 len = ssnprintf (pi, size, "%s_%s%u", inet_ntoa (addr),
194 (se->protocol == IPPROTO_TCP) ? "TCP" : "UDP",
197 if ((0 > len) || (size <= ((size_t) len))) {
198 log_err ("plugin instance truncated: %s", pi);
205 static int get_ti (struct ip_vs_dest_entry *de, char *ti, size_t size)
210 if ((NULL == de) || (NULL == ti))
213 addr.s_addr = de->addr;
215 /* inet_ntoa() returns a pointer to a statically allocated buffer
216 * I hope non-glibc systems behave the same */
217 len = ssnprintf (ti, size, "%s_%u", inet_ntoa (addr),
220 if ((0 > len) || (size <= ((size_t) len))) {
221 log_err ("type instance truncated: %s", ti);
227 static void cipvs_submit_connections (const char *pi, const char *ti,
231 value_list_t vl = VALUE_LIST_INIT;
233 values[0].derive = value;
238 sstrncpy (vl.host, hostname_g, sizeof (vl.host));
239 sstrncpy (vl.plugin, "ipvs", sizeof (vl.plugin));
240 sstrncpy (vl.plugin_instance, pi, sizeof (vl.plugin_instance));
241 sstrncpy (vl.type, "connections", sizeof (vl.type));
242 sstrncpy (vl.type_instance, (NULL != ti) ? ti : "total",
243 sizeof (vl.type_instance));
245 plugin_dispatch_values (&vl);
247 } /* cipvs_submit_connections */
249 static void cipvs_submit_if (const char *pi, const char *t, const char *ti,
250 derive_t rx, derive_t tx)
253 value_list_t vl = VALUE_LIST_INIT;
255 values[0].derive = rx;
256 values[1].derive = tx;
261 sstrncpy (vl.host, hostname_g, sizeof (vl.host));
262 sstrncpy (vl.plugin, "ipvs", sizeof (vl.plugin));
263 sstrncpy (vl.plugin_instance, pi, sizeof (vl.plugin_instance));
264 sstrncpy (vl.type, t, sizeof (vl.type));
265 sstrncpy (vl.type_instance, (NULL != ti) ? ti : "total",
266 sizeof (vl.type_instance));
268 plugin_dispatch_values (&vl);
270 } /* cipvs_submit_if */
272 static void cipvs_submit_dest (const char *pi, struct ip_vs_dest_entry *de)
274 struct ip_vs_stats_user stats = de->stats;
276 char ti[DATA_MAX_NAME_LEN];
278 if (0 != get_ti (de, ti, sizeof (ti)))
281 cipvs_submit_connections (pi, ti, stats.conns);
282 cipvs_submit_if (pi, "if_packets", ti, stats.inpkts, stats.outpkts);
283 cipvs_submit_if (pi, "if_octets", ti, stats.inbytes, stats.outbytes);
285 } /* cipvs_submit_dest */
287 static void cipvs_submit_service (struct ip_vs_service_entry *se)
289 struct ip_vs_stats_user stats = se->stats;
290 struct ip_vs_get_dests *dests = ipvs_get_dests (se);
292 char pi[DATA_MAX_NAME_LEN];
296 if (0 != get_pi (se, pi, sizeof (pi)))
302 cipvs_submit_connections (pi, NULL, stats.conns);
303 cipvs_submit_if (pi, "if_packets", NULL, stats.inpkts, stats.outpkts);
304 cipvs_submit_if (pi, "if_octets", NULL, stats.inbytes, stats.outbytes);
306 for (i = 0; i < dests->num_dests; ++i)
307 cipvs_submit_dest (pi, &dests->entrytable[i]);
311 } /* cipvs_submit_service */
313 static int cipvs_read (void)
315 struct ip_vs_get_services *services = NULL;
321 if (NULL == (services = ipvs_get_services ()))
324 for (i = 0; i < services->num_services; ++i)
325 cipvs_submit_service (&services->entrytable[i]);
331 static int cipvs_shutdown (void)
338 } /* cipvs_shutdown */
340 void module_register (void)
342 plugin_register_init ("ipvs", cipvs_init);
343 plugin_register_read ("ipvs", cipvs_read);
344 plugin_register_shutdown ("ipvs", cipvs_shutdown);
346 } /* module_register */
348 /* vim: set sw=4 ts=4 tw=78 noexpandtab : */