Code

Tree wide: Reformat with clang-format.
[collectd.git] / src / ipvs.c
1 /**
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
7  *
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.
11  *
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.
16  *
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
20  *
21  * Authors:
22  *   Sebastian Harl <sh at tokkee.org>
23  **/
25 /*
26  * This plugin collects statistics about IPVS connections. It requires Linux
27  * kernels >= 2.6.
28  *
29  * See http://www.linuxvirtualserver.org/software/index.html for more
30  * information about IPVS.
31  */
33 #include "collectd.h"
35 #include "common.h"
36 #include "plugin.h"
38 #if HAVE_ARPA_INET_H
39 #include <arpa/inet.h>
40 #endif /* HAVE_ARPA_INET_H */
41 #if HAVE_NETINET_IN_H
42 #include <netinet/in.h>
43 #endif /* HAVE_NETINET_IN_H */
45 /* this can probably only be found in the kernel sources */
46 #if HAVE_LINUX_IP_VS_H
47 #include <linux/ip_vs.h>
48 #elif HAVE_NET_IP_VS_H
49 #include <net/ip_vs.h>
50 #elif HAVE_IP_VS_H
51 #include <ip_vs.h>
52 #endif /* HAVE_IP_VS_H */
54 #define log_err(...) ERROR("ipvs: " __VA_ARGS__)
55 #define log_info(...) INFO("ipvs: " __VA_ARGS__)
57 /*
58  * private variables
59  */
60 static int sockfd = -1;
62 /*
63  * libipvs API
64  */
65 static struct ip_vs_get_services *ipvs_get_services(void) {
66   struct ip_vs_getinfo ipvs_info;
67   struct ip_vs_get_services *ret;
69   socklen_t len;
71   len = sizeof(ipvs_info);
73   if (0 != getsockopt(sockfd, IPPROTO_IP, IP_VS_SO_GET_INFO, (void *)&ipvs_info,
74                       &len)) {
75     char errbuf[1024];
76     log_err("ip_vs_get_services: getsockopt() failed: %s",
77             sstrerror(errno, errbuf, sizeof(errbuf)));
78     return NULL;
79   }
81   len = sizeof(*ret) +
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.");
86     exit(3);
87   }
89   ret->num_services = ipvs_info.num_services;
91   if (0 != getsockopt(sockfd, IPPROTO_IP, IP_VS_SO_GET_SERVICES, (void *)ret,
92                       &len)) {
93     char errbuf[1024];
94     log_err("ipvs_get_services: getsockopt failed: %s",
95             sstrerror(errno, errbuf, sizeof(errbuf)));
97     free(ret);
98     return NULL;
99   }
100   return ret;
101 } /* ipvs_get_services */
103 static struct ip_vs_get_dests *ipvs_get_dests(struct ip_vs_service_entry *se) {
104   struct ip_vs_get_dests *ret;
105   socklen_t len;
107   len = sizeof(*ret) + sizeof(struct ip_vs_dest_entry) * se->num_dests;
109   if (NULL == (ret = malloc(len))) {
110     log_err("ipvs_get_dests: Out of memory.");
111     exit(3);
112   }
114   ret->fwmark = se->fwmark;
115   ret->protocol = se->protocol;
116   ret->addr = se->addr;
117   ret->port = se->port;
118   ret->num_dests = se->num_dests;
120   if (0 !=
121       getsockopt(sockfd, IPPROTO_IP, IP_VS_SO_GET_DESTS, (void *)ret, &len)) {
122     char errbuf[1024];
123     log_err("ipvs_get_dests: getsockopt() failed: %s",
124             sstrerror(errno, errbuf, sizeof(errbuf)));
125     free(ret);
126     return NULL;
127   }
128   return ret;
129 } /* ip_vs_get_dests */
131 /*
132  * collectd plugin API and helper functions
133  */
134 static int cipvs_init(void) {
135   struct ip_vs_getinfo ipvs_info;
137   socklen_t len;
139   if (-1 == (sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW))) {
140     char errbuf[1024];
141     log_err("cipvs_init: socket() failed: %s",
142             sstrerror(errno, errbuf, sizeof(errbuf)));
143     return -1;
144   }
146   len = sizeof(ipvs_info);
148   if (0 != getsockopt(sockfd, IPPROTO_IP, IP_VS_SO_GET_INFO, (void *)&ipvs_info,
149                       &len)) {
150     char errbuf[1024];
151     log_err("cipvs_init: getsockopt() failed: %s",
152             sstrerror(errno, errbuf, sizeof(errbuf)));
153     close(sockfd);
154     sockfd = -1;
155     return -1;
156   }
158   /* we need IPVS >= 1.1.4 */
159   if (ipvs_info.version < ((1 << 16) + (1 << 8) + 4)) {
160     log_err("cipvs_init: IPVS version too old (%d.%d.%d < %d.%d.%d)",
161             NVERSION(ipvs_info.version), 1, 1, 4);
162     close(sockfd);
163     sockfd = -1;
164     return -1;
165   } else {
166     log_info("Successfully connected to IPVS %d.%d.%d",
167              NVERSION(ipvs_info.version));
168   }
169   return 0;
170 } /* cipvs_init */
172 /*
173  * ipvs-<virtual IP>_{UDP,TCP}<port>/<type>-total
174  * ipvs-<virtual IP>_{UDP,TCP}<port>/<type>-<real IP>_<port>
175  */
177 /* plugin instance */
178 static int get_pi(struct ip_vs_service_entry *se, char *pi, size_t size) {
179   struct in_addr addr;
180   int len = 0;
182   if ((NULL == se) || (NULL == pi))
183     return 0;
185   addr.s_addr = se->addr;
187   /* inet_ntoa() returns a pointer to a statically allocated buffer
188    * I hope non-glibc systems behave the same */
189   len =
190       ssnprintf(pi, size, "%s_%s%u", inet_ntoa(addr),
191                 (se->protocol == IPPROTO_TCP) ? "TCP" : "UDP", ntohs(se->port));
193   if ((0 > len) || (size <= ((size_t)len))) {
194     log_err("plugin instance truncated: %s", pi);
195     return -1;
196   }
197   return 0;
198 } /* get_pi */
200 /* type instance */
201 static int get_ti(struct ip_vs_dest_entry *de, char *ti, size_t size) {
202   struct in_addr addr;
203   int len = 0;
205   if ((NULL == de) || (NULL == ti))
206     return 0;
208   addr.s_addr = de->addr;
210   /* inet_ntoa() returns a pointer to a statically allocated buffer
211    * I hope non-glibc systems behave the same */
212   len = ssnprintf(ti, size, "%s_%u", inet_ntoa(addr), ntohs(de->port));
214   if ((0 > len) || (size <= ((size_t)len))) {
215     log_err("type instance truncated: %s", ti);
216     return -1;
217   }
218   return 0;
219 } /* get_ti */
221 static void cipvs_submit_connections(const char *pi, const char *ti,
222                                      derive_t value) {
223   value_t values[1];
224   value_list_t vl = VALUE_LIST_INIT;
226   values[0].derive = value;
228   vl.values = values;
229   vl.values_len = 1;
231   sstrncpy(vl.host, hostname_g, sizeof(vl.host));
232   sstrncpy(vl.plugin, "ipvs", sizeof(vl.plugin));
233   sstrncpy(vl.plugin_instance, pi, sizeof(vl.plugin_instance));
234   sstrncpy(vl.type, "connections", sizeof(vl.type));
235   sstrncpy(vl.type_instance, (NULL != ti) ? ti : "total",
236            sizeof(vl.type_instance));
238   plugin_dispatch_values(&vl);
239   return;
240 } /* cipvs_submit_connections */
242 static void cipvs_submit_if(const char *pi, const char *t, const char *ti,
243                             derive_t rx, derive_t tx) {
244   value_t values[2];
245   value_list_t vl = VALUE_LIST_INIT;
247   values[0].derive = rx;
248   values[1].derive = tx;
250   vl.values = values;
251   vl.values_len = 2;
253   sstrncpy(vl.host, hostname_g, sizeof(vl.host));
254   sstrncpy(vl.plugin, "ipvs", sizeof(vl.plugin));
255   sstrncpy(vl.plugin_instance, pi, sizeof(vl.plugin_instance));
256   sstrncpy(vl.type, t, sizeof(vl.type));
257   sstrncpy(vl.type_instance, (NULL != ti) ? ti : "total",
258            sizeof(vl.type_instance));
260   plugin_dispatch_values(&vl);
261   return;
262 } /* cipvs_submit_if */
264 static void cipvs_submit_dest(const char *pi, struct ip_vs_dest_entry *de) {
265   struct ip_vs_stats_user stats = de->stats;
267   char ti[DATA_MAX_NAME_LEN];
269   if (0 != get_ti(de, ti, sizeof(ti)))
270     return;
272   cipvs_submit_connections(pi, ti, stats.conns);
273   cipvs_submit_if(pi, "if_packets", ti, stats.inpkts, stats.outpkts);
274   cipvs_submit_if(pi, "if_octets", ti, stats.inbytes, stats.outbytes);
275   return;
276 } /* cipvs_submit_dest */
278 static void cipvs_submit_service(struct ip_vs_service_entry *se) {
279   struct ip_vs_stats_user stats = se->stats;
280   struct ip_vs_get_dests *dests = ipvs_get_dests(se);
282   char pi[DATA_MAX_NAME_LEN];
284   if (0 != get_pi(se, pi, sizeof(pi))) {
285     free(dests);
286     return;
287   }
289   cipvs_submit_connections(pi, NULL, stats.conns);
290   cipvs_submit_if(pi, "if_packets", NULL, stats.inpkts, stats.outpkts);
291   cipvs_submit_if(pi, "if_octets", NULL, stats.inbytes, stats.outbytes);
293   for (size_t i = 0; i < dests->num_dests; ++i)
294     cipvs_submit_dest(pi, &dests->entrytable[i]);
296   free(dests);
297   return;
298 } /* cipvs_submit_service */
300 static int cipvs_read(void) {
301   struct ip_vs_get_services *services = NULL;
303   if (sockfd < 0)
304     return (-1);
306   if (NULL == (services = ipvs_get_services()))
307     return -1;
309   for (size_t i = 0; i < services->num_services; ++i)
310     cipvs_submit_service(&services->entrytable[i]);
312   free(services);
313   return 0;
314 } /* cipvs_read */
316 static int cipvs_shutdown(void) {
317   if (sockfd >= 0)
318     close(sockfd);
319   sockfd = -1;
321   return 0;
322 } /* cipvs_shutdown */
324 void module_register(void) {
325   plugin_register_init("ipvs", cipvs_init);
326   plugin_register_read("ipvs", cipvs_read);
327   plugin_register_shutdown("ipvs", cipvs_shutdown);
328   return;
329 } /* module_register */
331 /* vim: set sw=4 ts=4 tw=78 noexpandtab : */