gps plugin: Replace busy loop with pthread_cond_timedwait().
[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  **/
24
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  */
32
33 #include "collectd.h"
34
35 #include "plugin.h"
36 #include "common.h"
37
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 */
44
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 */
53
54 #define log_err(...) ERROR ("ipvs: " __VA_ARGS__)
55 #define log_info(...) INFO ("ipvs: " __VA_ARGS__)
56
57 /*
58  * private variables
59  */
60 static int sockfd = -1;
61
62 /*
63  * libipvs API
64  */
65 static struct ip_vs_get_services *ipvs_get_services (void)
66 {
67         struct ip_vs_getinfo       ipvs_info;
68         struct ip_vs_get_services *ret;
69
70         socklen_t len;
71
72         len = sizeof (ipvs_info);
73
74         if (0 != getsockopt (sockfd, IPPROTO_IP, IP_VS_SO_GET_INFO,
75                                 (void *)&ipvs_info, &len)) {
76                 char errbuf[1024];
77                 log_err ("ip_vs_get_services: getsockopt() failed: %s",
78                                 sstrerror (errno, errbuf, sizeof (errbuf)));
79                 return NULL;
80         }
81
82         len = sizeof (*ret) +
83                 sizeof (struct ip_vs_service_entry) * ipvs_info.num_services;
84
85         if (NULL == (ret = malloc (len))) {
86                 log_err ("ipvs_get_services: Out of memory.");
87                 exit (3);
88         }
89
90         ret->num_services = ipvs_info.num_services;
91
92         if (0 != getsockopt (sockfd, IPPROTO_IP, IP_VS_SO_GET_SERVICES,
93                                 (void *)ret, &len)) {
94                 char errbuf[1024];
95                 log_err ("ipvs_get_services: getsockopt failed: %s",
96                                 sstrerror (errno, errbuf, sizeof (errbuf)));
97
98                 free(ret);
99                 return NULL;
100         }
101         return ret;
102 } /* ipvs_get_services */
103
104 static struct ip_vs_get_dests *ipvs_get_dests (struct ip_vs_service_entry *se)
105 {
106         struct ip_vs_get_dests *ret;
107         socklen_t len;
108
109         len = sizeof (*ret) + sizeof (struct ip_vs_dest_entry) * se->num_dests;
110
111         if (NULL == (ret = malloc (len))) {
112                 log_err ("ipvs_get_dests: Out of memory.");
113                 exit (3);
114         }
115
116         ret->fwmark    = se->fwmark;
117         ret->protocol  = se->protocol;
118         ret->addr      = se->addr;
119         ret->port      = se->port;
120         ret->num_dests = se->num_dests;
121
122         if (0 != getsockopt (sockfd, IPPROTO_IP, IP_VS_SO_GET_DESTS,
123                                 (void *)ret, &len)) {
124                 char errbuf[1024];
125                 log_err ("ipvs_get_dests: getsockopt() failed: %s",
126                                 sstrerror (errno, errbuf, sizeof (errbuf)));
127                 free (ret);
128                 return NULL;
129         }
130         return ret;
131 } /* ip_vs_get_dests */
132
133 /*
134  * collectd plugin API and helper functions
135  */
136 static int cipvs_init (void)
137 {
138         struct ip_vs_getinfo ipvs_info;
139
140         socklen_t len;
141
142         if (-1 == (sockfd = socket (AF_INET, SOCK_RAW, IPPROTO_RAW))) {
143                 char errbuf[1024];
144                 log_err ("cipvs_init: socket() failed: %s",
145                                 sstrerror (errno, errbuf, sizeof (errbuf)));
146                 return -1;
147         }
148
149         len = sizeof (ipvs_info);
150
151         if (0 != getsockopt (sockfd, IPPROTO_IP, IP_VS_SO_GET_INFO,
152                                 (void *)&ipvs_info, &len)) {
153                 char errbuf[1024];
154                 log_err ("cipvs_init: getsockopt() failed: %s",
155                                 sstrerror (errno, errbuf, sizeof (errbuf)));
156                 close (sockfd);
157                 sockfd = -1;
158                 return -1;
159         }
160
161         /* we need IPVS >= 1.1.4 */
162         if (ipvs_info.version < ((1 << 16) + (1 << 8) + 4)) {
163                 log_err ("cipvs_init: IPVS version too old (%d.%d.%d < %d.%d.%d)",
164                                 NVERSION (ipvs_info.version), 1, 1, 4);
165                 close (sockfd);
166                 sockfd = -1;
167                 return -1;
168         }
169         else {
170                 log_info ("Successfully connected to IPVS %d.%d.%d",
171                                 NVERSION (ipvs_info.version));
172         }
173         return 0;
174 } /* cipvs_init */
175
176 /*
177  * ipvs-<virtual IP>_{UDP,TCP}<port>/<type>-total
178  * ipvs-<virtual IP>_{UDP,TCP}<port>/<type>-<real IP>_<port>
179  */
180
181 /* plugin instance */
182 static int get_pi (struct ip_vs_service_entry *se, char *pi, size_t size)
183 {
184         struct in_addr addr;
185         int len = 0;
186
187         if ((NULL == se) || (NULL == pi))
188                 return 0;
189
190         addr.s_addr = se->addr;
191
192         /* inet_ntoa() returns a pointer to a statically allocated buffer
193          * I hope non-glibc systems behave the same */
194         len = ssnprintf (pi, size, "%s_%s%u", inet_ntoa (addr),
195                         (se->protocol == IPPROTO_TCP) ? "TCP" : "UDP",
196                         ntohs (se->port));
197
198         if ((0 > len) || (size <= ((size_t) len))) {
199                 log_err ("plugin instance truncated: %s", pi);
200                 return -1;
201         }
202         return 0;
203 } /* get_pi */
204
205 /* type instance */
206 static int get_ti (struct ip_vs_dest_entry *de, char *ti, size_t size)
207 {
208         struct in_addr addr;
209         int len = 0;
210
211         if ((NULL == de) || (NULL == ti))
212                 return 0;
213
214         addr.s_addr = de->addr;
215
216         /* inet_ntoa() returns a pointer to a statically allocated buffer
217          * I hope non-glibc systems behave the same */
218         len = ssnprintf (ti, size, "%s_%u", inet_ntoa (addr),
219                         ntohs (de->port));
220
221         if ((0 > len) || (size <= ((size_t) len))) {
222                 log_err ("type instance truncated: %s", ti);
223                 return -1;
224         }
225         return 0;
226 } /* get_ti */
227
228 static void cipvs_submit_connections (const char *pi, const char *ti,
229                 derive_t value)
230 {
231         value_list_t vl = VALUE_LIST_INIT;
232
233         vl.values     = &(value_t) { .derive = value };
234         vl.values_len = 1;
235
236         sstrncpy (vl.plugin, "ipvs", sizeof (vl.plugin));
237         sstrncpy (vl.plugin_instance, pi, sizeof (vl.plugin_instance));
238         sstrncpy (vl.type, "connections", sizeof (vl.type));
239         sstrncpy (vl.type_instance, (NULL != ti) ? ti : "total",
240                 sizeof (vl.type_instance));
241
242         plugin_dispatch_values (&vl);
243         return;
244 } /* cipvs_submit_connections */
245
246 static void cipvs_submit_if (const char *pi, const char *t, const char *ti,
247                 derive_t rx, derive_t tx)
248 {
249         value_t values[] = {
250                 { .derive = rx },
251                 { .derive = tx },
252         };
253         value_list_t vl = VALUE_LIST_INIT;
254
255         vl.values     = values;
256         vl.values_len = STATIC_ARRAY_SIZE (values);
257
258         sstrncpy (vl.plugin, "ipvs", sizeof (vl.plugin));
259         sstrncpy (vl.plugin_instance, pi, sizeof (vl.plugin_instance));
260         sstrncpy (vl.type, t, sizeof (vl.type));
261         sstrncpy (vl.type_instance, (NULL != ti) ? ti : "total",
262                 sizeof (vl.type_instance));
263
264         plugin_dispatch_values (&vl);
265         return;
266 } /* cipvs_submit_if */
267
268 static void cipvs_submit_dest (const char *pi, struct ip_vs_dest_entry *de)
269 {
270         struct ip_vs_stats_user stats = de->stats;
271
272         char ti[DATA_MAX_NAME_LEN];
273
274         if (0 != get_ti (de, ti, sizeof (ti)))
275                 return;
276
277         cipvs_submit_connections (pi, ti, stats.conns);
278         cipvs_submit_if (pi, "if_packets", ti, stats.inpkts, stats.outpkts);
279         cipvs_submit_if (pi, "if_octets", ti, stats.inbytes, stats.outbytes);
280         return;
281 } /* cipvs_submit_dest */
282
283 static void cipvs_submit_service (struct ip_vs_service_entry *se)
284 {
285         struct ip_vs_stats_user  stats = se->stats;
286         struct ip_vs_get_dests  *dests = ipvs_get_dests (se);
287
288         char pi[DATA_MAX_NAME_LEN];
289
290         if (0 != get_pi (se, pi, sizeof (pi)))
291         {
292                 free (dests);
293                 return;
294         }
295
296         cipvs_submit_connections (pi, NULL, stats.conns);
297         cipvs_submit_if (pi, "if_packets", NULL, stats.inpkts, stats.outpkts);
298         cipvs_submit_if (pi, "if_octets", NULL, stats.inbytes, stats.outbytes);
299
300         for (size_t i = 0; i < dests->num_dests; ++i)
301                 cipvs_submit_dest (pi, &dests->entrytable[i]);
302
303         free (dests);
304         return;
305 } /* cipvs_submit_service */
306
307 static int cipvs_read (void)
308 {
309         struct ip_vs_get_services *services = NULL;
310
311         if (sockfd < 0)
312                 return (-1);
313
314         if (NULL == (services = ipvs_get_services ()))
315                 return -1;
316
317         for (size_t i = 0; i < services->num_services; ++i)
318                 cipvs_submit_service (&services->entrytable[i]);
319
320         free (services);
321         return 0;
322 } /* cipvs_read */
323
324 static int cipvs_shutdown (void)
325 {
326         if (sockfd >= 0)
327                 close (sockfd);
328         sockfd = -1;
329
330         return 0;
331 } /* cipvs_shutdown */
332
333 void module_register (void)
334 {
335         plugin_register_init ("ipvs", cipvs_init);
336         plugin_register_read ("ipvs", cipvs_read);
337         plugin_register_shutdown ("ipvs", cipvs_shutdown);
338         return;
339 } /* module_register */
340
341 /* vim: set sw=4 ts=4 tw=78 noexpandtab : */