blob: fe82b1e10a296b4892d5ccb9c4ad7ba94b8f82a9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * IP Virtual Server
3 * data structure and functionality definitions
4 */
5
Julius Volzbc4768e2008-07-31 20:45:24 -07006#ifndef _NET_IP_VS_H
7#define _NET_IP_VS_H
Linus Torvalds1da177e2005-04-16 15:20:36 -07008
Julius Volzbc4768e2008-07-31 20:45:24 -07009#include <linux/ip_vs.h> /* definitions shared with userland */
Linus Torvalds1da177e2005-04-16 15:20:36 -070010
Julius Volzbc4768e2008-07-31 20:45:24 -070011/* old ipvsadm versions still include this file directly */
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#ifdef __KERNEL__
13
Julius Volzbc4768e2008-07-31 20:45:24 -070014#include <asm/types.h> /* for __uXX types */
15
16#include <linux/sysctl.h> /* for ctl_path */
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/list.h> /* for struct list_head */
18#include <linux/spinlock.h> /* for struct rwlock_t */
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <asm/atomic.h> /* for struct atomic_t */
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/compiler.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020021#include <linux/timer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020023#include <net/checksum.h>
Julius Volze7ade462008-09-02 15:55:33 +020024#include <linux/netfilter.h> /* for union nf_inet_addr */
KOVACS Krisztian1668e012008-10-01 07:33:10 -070025#include <linux/ip.h>
Julius Volze7ade462008-09-02 15:55:33 +020026#include <linux/ipv6.h> /* for struct ipv6hdr */
27#include <net/ipv6.h> /* for ipv6_addr_copy */
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
Catalin(ux) M. BOIE6f7edb42010-01-05 05:50:24 +010029
30/* Connections' size value needed by ip_vs_ctl.c */
31extern int ip_vs_conn_tab_size;
32
33
Julius Volz64aae3c2008-09-02 15:55:34 +020034struct ip_vs_iphdr {
35 int len;
36 __u8 protocol;
37 union nf_inet_addr saddr;
38 union nf_inet_addr daddr;
39};
40
41static inline void
42ip_vs_fill_iphdr(int af, const void *nh, struct ip_vs_iphdr *iphdr)
43{
44#ifdef CONFIG_IP_VS_IPV6
45 if (af == AF_INET6) {
46 const struct ipv6hdr *iph = nh;
47 iphdr->len = sizeof(struct ipv6hdr);
48 iphdr->protocol = iph->nexthdr;
49 ipv6_addr_copy(&iphdr->saddr.in6, &iph->saddr);
50 ipv6_addr_copy(&iphdr->daddr.in6, &iph->daddr);
51 } else
52#endif
53 {
54 const struct iphdr *iph = nh;
55 iphdr->len = iph->ihl * 4;
56 iphdr->protocol = iph->protocol;
57 iphdr->saddr.ip = iph->saddr;
58 iphdr->daddr.ip = iph->daddr;
59 }
60}
61
62static inline void ip_vs_addr_copy(int af, union nf_inet_addr *dst,
63 const union nf_inet_addr *src)
64{
65#ifdef CONFIG_IP_VS_IPV6
66 if (af == AF_INET6)
67 ipv6_addr_copy(&dst->in6, &src->in6);
68 else
69#endif
70 dst->ip = src->ip;
71}
72
73static inline int ip_vs_addr_equal(int af, const union nf_inet_addr *a,
74 const union nf_inet_addr *b)
75{
76#ifdef CONFIG_IP_VS_IPV6
77 if (af == AF_INET6)
78 return ipv6_addr_equal(&a->in6, &b->in6);
79#endif
80 return a->ip == b->ip;
81}
82
Linus Torvalds1da177e2005-04-16 15:20:36 -070083#ifdef CONFIG_IP_VS_DEBUG
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020084#include <linux/net.h>
85
Linus Torvalds1da177e2005-04-16 15:20:36 -070086extern int ip_vs_get_debug_level(void);
Julius Volzc842a3a2008-09-02 15:55:35 +020087
88static inline const char *ip_vs_dbg_addr(int af, char *buf, size_t buf_len,
89 const union nf_inet_addr *addr,
90 int *idx)
91{
92 int len;
93#ifdef CONFIG_IP_VS_IPV6
94 if (af == AF_INET6)
Harvey Harrison5b095d9892008-10-29 12:52:50 -070095 len = snprintf(&buf[*idx], buf_len - *idx, "[%pI6]",
Harvey Harrison0c6ce782008-10-28 16:09:23 -070096 &addr->in6) + 1;
Julius Volzc842a3a2008-09-02 15:55:35 +020097 else
98#endif
Harvey Harrison3685f25d2008-10-31 00:56:49 -070099 len = snprintf(&buf[*idx], buf_len - *idx, "%pI4",
100 &addr->ip) + 1;
Julius Volzc842a3a2008-09-02 15:55:35 +0200101
102 *idx += len;
103 BUG_ON(*idx > buf_len + 1);
104 return &buf[*idx - len];
105}
106
Hannes Eder9aada7a2009-07-30 14:29:44 -0700107#define IP_VS_DBG_BUF(level, msg, ...) \
108 do { \
109 char ip_vs_dbg_buf[160]; \
110 int ip_vs_dbg_idx = 0; \
111 if (level <= ip_vs_get_debug_level()) \
112 printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__); \
113 } while (0)
114#define IP_VS_ERR_BUF(msg...) \
115 do { \
116 char ip_vs_dbg_buf[160]; \
117 int ip_vs_dbg_idx = 0; \
118 pr_err(msg); \
119 } while (0)
Julius Volzc842a3a2008-09-02 15:55:35 +0200120
121/* Only use from within IP_VS_DBG_BUF() or IP_VS_ERR_BUF macros */
Hannes Eder9aada7a2009-07-30 14:29:44 -0700122#define IP_VS_DBG_ADDR(af, addr) \
123 ip_vs_dbg_addr(af, ip_vs_dbg_buf, \
124 sizeof(ip_vs_dbg_buf), addr, \
125 &ip_vs_dbg_idx)
Julius Volzc842a3a2008-09-02 15:55:35 +0200126
Hannes Eder9aada7a2009-07-30 14:29:44 -0700127#define IP_VS_DBG(level, msg, ...) \
128 do { \
129 if (level <= ip_vs_get_debug_level()) \
130 printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__); \
131 } while (0)
132#define IP_VS_DBG_RL(msg, ...) \
133 do { \
134 if (net_ratelimit()) \
135 printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__); \
136 } while (0)
137#define IP_VS_DBG_PKT(level, pp, skb, ofs, msg) \
138 do { \
139 if (level <= ip_vs_get_debug_level()) \
140 pp->debug_packet(pp, skb, ofs, msg); \
141 } while (0)
142#define IP_VS_DBG_RL_PKT(level, pp, skb, ofs, msg) \
143 do { \
144 if (level <= ip_vs_get_debug_level() && \
145 net_ratelimit()) \
146 pp->debug_packet(pp, skb, ofs, msg); \
147 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148#else /* NO DEBUGGING at ALL */
Julius Volzc842a3a2008-09-02 15:55:35 +0200149#define IP_VS_DBG_BUF(level, msg...) do {} while (0)
150#define IP_VS_ERR_BUF(msg...) do {} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151#define IP_VS_DBG(level, msg...) do {} while (0)
152#define IP_VS_DBG_RL(msg...) do {} while (0)
153#define IP_VS_DBG_PKT(level, pp, skb, ofs, msg) do {} while (0)
154#define IP_VS_DBG_RL_PKT(level, pp, skb, ofs, msg) do {} while (0)
155#endif
156
157#define IP_VS_BUG() BUG()
Hannes Eder1e3e2382009-08-02 11:05:41 +0000158#define IP_VS_ERR_RL(msg, ...) \
Hannes Eder9aada7a2009-07-30 14:29:44 -0700159 do { \
160 if (net_ratelimit()) \
Hannes Eder1e3e2382009-08-02 11:05:41 +0000161 pr_err(msg, ##__VA_ARGS__); \
Hannes Eder9aada7a2009-07-30 14:29:44 -0700162 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
164#ifdef CONFIG_IP_VS_DEBUG
165#define EnterFunction(level) \
Hannes Eder9aada7a2009-07-30 14:29:44 -0700166 do { \
167 if (level <= ip_vs_get_debug_level()) \
168 printk(KERN_DEBUG \
169 pr_fmt("Enter: %s, %s line %i\n"), \
170 __func__, __FILE__, __LINE__); \
171 } while (0)
172#define LeaveFunction(level) \
173 do { \
174 if (level <= ip_vs_get_debug_level()) \
175 printk(KERN_DEBUG \
176 pr_fmt("Leave: %s, %s line %i\n"), \
177 __func__, __FILE__, __LINE__); \
178 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179#else
180#define EnterFunction(level) do {} while (0)
181#define LeaveFunction(level) do {} while (0)
182#endif
183
184#define IP_VS_WAIT_WHILE(expr) while (expr) { cpu_relax(); }
185
186
187/*
188 * The port number of FTP service (in network order).
189 */
Harvey Harrisonf3a7c662009-02-14 22:58:35 -0800190#define FTPPORT cpu_to_be16(21)
191#define FTPDATA cpu_to_be16(20)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
193/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 * TCP State Values
195 */
196enum {
197 IP_VS_TCP_S_NONE = 0,
198 IP_VS_TCP_S_ESTABLISHED,
199 IP_VS_TCP_S_SYN_SENT,
200 IP_VS_TCP_S_SYN_RECV,
201 IP_VS_TCP_S_FIN_WAIT,
202 IP_VS_TCP_S_TIME_WAIT,
203 IP_VS_TCP_S_CLOSE,
204 IP_VS_TCP_S_CLOSE_WAIT,
205 IP_VS_TCP_S_LAST_ACK,
206 IP_VS_TCP_S_LISTEN,
207 IP_VS_TCP_S_SYNACK,
208 IP_VS_TCP_S_LAST
209};
210
211/*
212 * UDP State Values
213 */
214enum {
215 IP_VS_UDP_S_NORMAL,
216 IP_VS_UDP_S_LAST,
217};
218
219/*
220 * ICMP State Values
221 */
222enum {
223 IP_VS_ICMP_S_NORMAL,
224 IP_VS_ICMP_S_LAST,
225};
226
227/*
Venkata Mohan Reddy2906f662010-02-18 12:31:05 +0100228 * SCTP State Values
229 */
230enum ip_vs_sctp_states {
231 IP_VS_SCTP_S_NONE,
232 IP_VS_SCTP_S_INIT_CLI,
233 IP_VS_SCTP_S_INIT_SER,
234 IP_VS_SCTP_S_INIT_ACK_CLI,
235 IP_VS_SCTP_S_INIT_ACK_SER,
236 IP_VS_SCTP_S_ECHO_CLI,
237 IP_VS_SCTP_S_ECHO_SER,
238 IP_VS_SCTP_S_ESTABLISHED,
239 IP_VS_SCTP_S_SHUT_CLI,
240 IP_VS_SCTP_S_SHUT_SER,
241 IP_VS_SCTP_S_SHUT_ACK_CLI,
242 IP_VS_SCTP_S_SHUT_ACK_SER,
243 IP_VS_SCTP_S_CLOSED,
244 IP_VS_SCTP_S_LAST
245};
246
247/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 * Delta sequence info structure
249 * Each ip_vs_conn has 2 (output AND input seq. changes).
250 * Only used in the VS/NAT.
251 */
252struct ip_vs_seq {
253 __u32 init_seq; /* Add delta from this seq */
254 __u32 delta; /* Delta in sequence numbers */
255 __u32 previous_delta; /* Delta in sequence numbers
256 before last resized pkt */
257};
258
259
260/*
Sven Wegener3a14a3132008-08-10 18:24:41 +0000261 * IPVS statistics objects
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 */
Sven Wegener3a14a3132008-08-10 18:24:41 +0000263struct ip_vs_estimator {
264 struct list_head list;
265
266 u64 last_inbytes;
267 u64 last_outbytes;
268 u32 last_conns;
269 u32 last_inpkts;
270 u32 last_outpkts;
271
272 u32 cps;
273 u32 inpps;
274 u32 outpps;
275 u32 inbps;
276 u32 outbps;
277};
278
Eric Dumazetfd2c3ef2009-11-03 03:26:03 +0000279struct ip_vs_stats {
Sven Wegenere9c0ce22008-09-08 13:39:04 +0200280 struct ip_vs_stats_user ustats; /* statistics */
281 struct ip_vs_estimator est; /* estimator */
Sven Wegener3a14a3132008-08-10 18:24:41 +0000282
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 spinlock_t lock; /* spin lock */
284};
285
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -0200286struct dst_entry;
287struct iphdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288struct ip_vs_conn;
289struct ip_vs_app;
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -0200290struct sk_buff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
292struct ip_vs_protocol {
293 struct ip_vs_protocol *next;
294 char *name;
Julian Anastasov2ad17de2008-04-29 03:21:23 -0700295 u16 protocol;
296 u16 num_states;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 int dont_defrag;
298 atomic_t appcnt; /* counter of proto app incs */
299 int *timeout_table; /* protocol timeout table */
300
301 void (*init)(struct ip_vs_protocol *pp);
302
303 void (*exit)(struct ip_vs_protocol *pp);
304
Julius Volz51ef3482008-09-02 15:55:40 +0200305 int (*conn_schedule)(int af, struct sk_buff *skb,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 struct ip_vs_protocol *pp,
307 int *verdict, struct ip_vs_conn **cpp);
308
309 struct ip_vs_conn *
Julius Volz51ef3482008-09-02 15:55:40 +0200310 (*conn_in_get)(int af,
311 const struct sk_buff *skb,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 struct ip_vs_protocol *pp,
Julius Volz51ef3482008-09-02 15:55:40 +0200313 const struct ip_vs_iphdr *iph,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 unsigned int proto_off,
315 int inverse);
316
317 struct ip_vs_conn *
Julius Volz51ef3482008-09-02 15:55:40 +0200318 (*conn_out_get)(int af,
319 const struct sk_buff *skb,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 struct ip_vs_protocol *pp,
Julius Volz51ef3482008-09-02 15:55:40 +0200321 const struct ip_vs_iphdr *iph,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 unsigned int proto_off,
323 int inverse);
324
Herbert Xu3db05fe2007-10-15 00:53:15 -0700325 int (*snat_handler)(struct sk_buff *skb,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 struct ip_vs_protocol *pp, struct ip_vs_conn *cp);
327
Herbert Xu3db05fe2007-10-15 00:53:15 -0700328 int (*dnat_handler)(struct sk_buff *skb,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 struct ip_vs_protocol *pp, struct ip_vs_conn *cp);
330
Julius Volz51ef3482008-09-02 15:55:40 +0200331 int (*csum_check)(int af, struct sk_buff *skb,
332 struct ip_vs_protocol *pp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333
334 const char *(*state_name)(int state);
335
336 int (*state_transition)(struct ip_vs_conn *cp, int direction,
337 const struct sk_buff *skb,
338 struct ip_vs_protocol *pp);
339
340 int (*register_app)(struct ip_vs_app *inc);
341
342 void (*unregister_app)(struct ip_vs_app *inc);
343
344 int (*app_conn_bind)(struct ip_vs_conn *cp);
345
346 void (*debug_packet)(struct ip_vs_protocol *pp,
347 const struct sk_buff *skb,
348 int offset,
349 const char *msg);
350
351 void (*timeout_change)(struct ip_vs_protocol *pp, int flags);
352
353 int (*set_state_timeout)(struct ip_vs_protocol *pp, char *sname, int to);
354};
355
356extern struct ip_vs_protocol * ip_vs_proto_get(unsigned short proto);
357
358/*
359 * IP_VS structure allocated for each dynamically scheduled connection
360 */
361struct ip_vs_conn {
362 struct list_head c_list; /* hashed list heads */
363
364 /* Protocol, addresses and port numbers */
Julius Volze7ade462008-09-02 15:55:33 +0200365 u16 af; /* address family */
366 union nf_inet_addr caddr; /* client address */
367 union nf_inet_addr vaddr; /* virtual address */
368 union nf_inet_addr daddr; /* destination address */
Al Viro014d7302006-09-28 14:29:52 -0700369 __be16 cport;
370 __be16 vport;
371 __be16 dport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 __u16 protocol; /* Which protocol (TCP/UDP) */
373
374 /* counter and timer */
375 atomic_t refcnt; /* reference count */
376 struct timer_list timer; /* Expiration timer */
377 volatile unsigned long timeout; /* timeout */
378
379 /* Flags and state transition */
380 spinlock_t lock; /* lock for state transition */
381 volatile __u16 flags; /* status flags */
382 volatile __u16 state; /* state info */
Rumen G. Bogdanovskiefac5272007-11-07 02:36:55 -0800383 volatile __u16 old_state; /* old state, to be used for
384 * state transition triggerd
385 * synchronization
386 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
388 /* Control members */
389 struct ip_vs_conn *control; /* Master control connection */
390 atomic_t n_control; /* Number of controlled ones */
391 struct ip_vs_dest *dest; /* real server */
392 atomic_t in_pkts; /* incoming packet counter */
393
394 /* packet transmitter for different forwarding methods. If it
395 mangles the packet, it must return NF_DROP or better NF_STOLEN,
396 otherwise this must be changed to a sk_buff **.
397 */
398 int (*packet_xmit)(struct sk_buff *skb, struct ip_vs_conn *cp,
399 struct ip_vs_protocol *pp);
400
401 /* Note: we can group the following members into a structure,
402 in order to save more space, and the following members are
403 only used in VS/NAT anyway */
404 struct ip_vs_app *app; /* bound ip_vs_app object */
405 void *app_data; /* Application private data */
406 struct ip_vs_seq in_seq; /* incoming seq. struct */
407 struct ip_vs_seq out_seq; /* outgoing seq. struct */
408};
409
410
411/*
Julius Volzc860c6b2008-09-02 15:55:36 +0200412 * Extended internal versions of struct ip_vs_service_user and
413 * ip_vs_dest_user for IPv6 support.
414 *
415 * We need these to conveniently pass around service and destination
416 * options, but unfortunately, we also need to keep the old definitions to
417 * maintain userspace backwards compatibility for the setsockopt interface.
418 */
419struct ip_vs_service_user_kern {
420 /* virtual service addresses */
421 u16 af;
422 u16 protocol;
423 union nf_inet_addr addr; /* virtual ip address */
424 u16 port;
425 u32 fwmark; /* firwall mark of service */
426
427 /* virtual service options */
428 char *sched_name;
429 unsigned flags; /* virtual service flags */
430 unsigned timeout; /* persistent timeout in sec */
431 u32 netmask; /* persistent netmask */
432};
433
434
435struct ip_vs_dest_user_kern {
436 /* destination server address */
437 union nf_inet_addr addr;
438 u16 port;
439
440 /* real server options */
441 unsigned conn_flags; /* connection flags */
442 int weight; /* destination weight */
443
444 /* thresholds for active connections */
445 u32 u_threshold; /* upper threshold */
446 u32 l_threshold; /* lower threshold */
447};
448
449
450/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 * The information about the virtual service offered to the net
452 * and the forwarding entries
453 */
454struct ip_vs_service {
455 struct list_head s_list; /* for normal service table */
456 struct list_head f_list; /* for fwmark-based service table */
457 atomic_t refcnt; /* reference counter */
458 atomic_t usecnt; /* use counter */
459
Julius Volze7ade462008-09-02 15:55:33 +0200460 u16 af; /* address family */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 __u16 protocol; /* which protocol (TCP/UDP) */
Julius Volze7ade462008-09-02 15:55:33 +0200462 union nf_inet_addr addr; /* IP address for virtual service */
Al Viro014d7302006-09-28 14:29:52 -0700463 __be16 port; /* port number for the service */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 __u32 fwmark; /* firewall mark of the service */
465 unsigned flags; /* service status flags */
466 unsigned timeout; /* persistent timeout in ticks */
Al Viro014d7302006-09-28 14:29:52 -0700467 __be32 netmask; /* grouping granularity */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
469 struct list_head destinations; /* real server d-linked list */
470 __u32 num_dests; /* number of servers */
471 struct ip_vs_stats stats; /* statistics for the service */
472 struct ip_vs_app *inc; /* bind conns to this app inc */
473
474 /* for scheduling */
475 struct ip_vs_scheduler *scheduler; /* bound scheduler object */
476 rwlock_t sched_lock; /* lock sched_data */
477 void *sched_data; /* scheduler application data */
478};
479
480
481/*
482 * The real server destination forwarding entry
483 * with ip address, port number, and so on.
484 */
485struct ip_vs_dest {
486 struct list_head n_list; /* for the dests in the service */
487 struct list_head d_list; /* for table with all the dests */
488
Julius Volze7ade462008-09-02 15:55:33 +0200489 u16 af; /* address family */
490 union nf_inet_addr addr; /* IP address of the server */
Al Viro014d7302006-09-28 14:29:52 -0700491 __be16 port; /* port number of the server */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 volatile unsigned flags; /* dest status flags */
493 atomic_t conn_flags; /* flags to copy to conn */
494 atomic_t weight; /* server weight */
495
496 atomic_t refcnt; /* reference counter */
497 struct ip_vs_stats stats; /* statistics */
498
499 /* connection counters and thresholds */
500 atomic_t activeconns; /* active connections */
501 atomic_t inactconns; /* inactive connections */
502 atomic_t persistconns; /* persistent connections */
503 __u32 u_threshold; /* upper threshold */
504 __u32 l_threshold; /* lower threshold */
505
506 /* for destination cache */
507 spinlock_t dst_lock; /* lock of dst_cache */
508 struct dst_entry *dst_cache; /* destination cache entry */
509 u32 dst_rtos; /* RT_TOS(tos) for dst */
510
511 /* for virtual service */
512 struct ip_vs_service *svc; /* service it belongs to */
513 __u16 protocol; /* which protocol (TCP/UDP) */
Julius Volze7ade462008-09-02 15:55:33 +0200514 union nf_inet_addr vaddr; /* virtual IP address */
Al Viro014d7302006-09-28 14:29:52 -0700515 __be16 vport; /* virtual port number */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 __u32 vfwmark; /* firewall mark of service */
517};
518
519
520/*
521 * The scheduler object
522 */
523struct ip_vs_scheduler {
524 struct list_head n_list; /* d-linked list head */
525 char *name; /* scheduler name */
526 atomic_t refcnt; /* reference counter */
527 struct module *module; /* THIS_MODULE/NULL */
528
529 /* scheduler initializing service */
530 int (*init_service)(struct ip_vs_service *svc);
531 /* scheduling service finish */
532 int (*done_service)(struct ip_vs_service *svc);
533 /* scheduler updating service */
534 int (*update_service)(struct ip_vs_service *svc);
535
536 /* selecting a server from the given service */
537 struct ip_vs_dest* (*schedule)(struct ip_vs_service *svc,
538 const struct sk_buff *skb);
539};
540
541
542/*
543 * The application module object (a.k.a. app incarnation)
544 */
Eric Dumazetfd2c3ef2009-11-03 03:26:03 +0000545struct ip_vs_app {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 struct list_head a_list; /* member in app list */
547 int type; /* IP_VS_APP_TYPE_xxx */
548 char *name; /* application module name */
549 __u16 protocol;
550 struct module *module; /* THIS_MODULE/NULL */
551 struct list_head incs_list; /* list of incarnations */
552
553 /* members for application incarnations */
554 struct list_head p_list; /* member in proto app list */
555 struct ip_vs_app *app; /* its real application */
Al Viro014d7302006-09-28 14:29:52 -0700556 __be16 port; /* port number in net order */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 atomic_t usecnt; /* usage counter */
558
559 /* output hook: return false if can't linearize. diff set for TCP. */
560 int (*pkt_out)(struct ip_vs_app *, struct ip_vs_conn *,
Herbert Xu3db05fe2007-10-15 00:53:15 -0700561 struct sk_buff *, int *diff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
563 /* input hook: return false if can't linearize. diff set for TCP. */
564 int (*pkt_in)(struct ip_vs_app *, struct ip_vs_conn *,
Herbert Xu3db05fe2007-10-15 00:53:15 -0700565 struct sk_buff *, int *diff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
567 /* ip_vs_app initializer */
568 int (*init_conn)(struct ip_vs_app *, struct ip_vs_conn *);
569
570 /* ip_vs_app finish */
571 int (*done_conn)(struct ip_vs_app *, struct ip_vs_conn *);
572
573
574 /* not used now */
575 int (*bind_conn)(struct ip_vs_app *, struct ip_vs_conn *,
576 struct ip_vs_protocol *);
577
578 void (*unbind_conn)(struct ip_vs_app *, struct ip_vs_conn *);
579
580 int * timeout_table;
581 int * timeouts;
582 int timeouts_size;
583
584 int (*conn_schedule)(struct sk_buff *skb, struct ip_vs_app *app,
585 int *verdict, struct ip_vs_conn **cpp);
586
587 struct ip_vs_conn *
588 (*conn_in_get)(const struct sk_buff *skb, struct ip_vs_app *app,
589 const struct iphdr *iph, unsigned int proto_off,
590 int inverse);
591
592 struct ip_vs_conn *
593 (*conn_out_get)(const struct sk_buff *skb, struct ip_vs_app *app,
594 const struct iphdr *iph, unsigned int proto_off,
595 int inverse);
596
597 int (*state_transition)(struct ip_vs_conn *cp, int direction,
598 const struct sk_buff *skb,
599 struct ip_vs_app *app);
600
601 void (*timeout_change)(struct ip_vs_app *app, int flags);
602};
603
604
605/*
606 * IPVS core functions
607 * (from ip_vs_core.c)
608 */
609extern const char *ip_vs_proto_name(unsigned proto);
610extern void ip_vs_init_hash_table(struct list_head *table, int rows);
Sven Wegenerafdd6142008-08-10 09:18:01 +0000611#define IP_VS_INIT_HASH_TABLE(t) ip_vs_init_hash_table((t), ARRAY_SIZE((t)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613#define IP_VS_APP_TYPE_FTP 1
614
615/*
616 * ip_vs_conn handling functions
617 * (from ip_vs_conn.c)
618 */
619
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620enum {
621 IP_VS_DIR_INPUT = 0,
622 IP_VS_DIR_OUTPUT,
623 IP_VS_DIR_INPUT_ONLY,
624 IP_VS_DIR_LAST,
625};
626
627extern struct ip_vs_conn *ip_vs_conn_in_get
Julius Volz28364a52008-09-02 15:55:43 +0200628(int af, int protocol, const union nf_inet_addr *s_addr, __be16 s_port,
629 const union nf_inet_addr *d_addr, __be16 d_port);
630
Julian Anastasov87375ab2005-09-14 21:08:51 -0700631extern struct ip_vs_conn *ip_vs_ct_in_get
Julius Volz28364a52008-09-02 15:55:43 +0200632(int af, int protocol, const union nf_inet_addr *s_addr, __be16 s_port,
633 const union nf_inet_addr *d_addr, __be16 d_port);
634
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635extern struct ip_vs_conn *ip_vs_conn_out_get
Julius Volz28364a52008-09-02 15:55:43 +0200636(int af, int protocol, const union nf_inet_addr *s_addr, __be16 s_port,
637 const union nf_inet_addr *d_addr, __be16 d_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638
639/* put back the conn without restarting its timer */
640static inline void __ip_vs_conn_put(struct ip_vs_conn *cp)
641{
642 atomic_dec(&cp->refcnt);
643}
644extern void ip_vs_conn_put(struct ip_vs_conn *cp);
Al Viro014d7302006-09-28 14:29:52 -0700645extern void ip_vs_conn_fill_cport(struct ip_vs_conn *cp, __be16 cport);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
647extern struct ip_vs_conn *
Julius Volz28364a52008-09-02 15:55:43 +0200648ip_vs_conn_new(int af, int proto, const union nf_inet_addr *caddr, __be16 cport,
649 const union nf_inet_addr *vaddr, __be16 vport,
650 const union nf_inet_addr *daddr, __be16 dport, unsigned flags,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 struct ip_vs_dest *dest);
652extern void ip_vs_conn_expire_now(struct ip_vs_conn *cp);
653
654extern const char * ip_vs_state_name(__u16 proto, int state);
655
656extern void ip_vs_tcp_conn_listen(struct ip_vs_conn *cp);
657extern int ip_vs_check_template(struct ip_vs_conn *ct);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658extern void ip_vs_random_dropentry(void);
659extern int ip_vs_conn_init(void);
660extern void ip_vs_conn_cleanup(void);
661
662static inline void ip_vs_control_del(struct ip_vs_conn *cp)
663{
664 struct ip_vs_conn *ctl_cp = cp->control;
665 if (!ctl_cp) {
Julius Volzcfc78c52008-09-02 15:55:53 +0200666 IP_VS_ERR_BUF("request control DEL for uncontrolled: "
667 "%s:%d to %s:%d\n",
668 IP_VS_DBG_ADDR(cp->af, &cp->caddr),
669 ntohs(cp->cport),
670 IP_VS_DBG_ADDR(cp->af, &cp->vaddr),
671 ntohs(cp->vport));
672
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 return;
674 }
675
Julius Volzcfc78c52008-09-02 15:55:53 +0200676 IP_VS_DBG_BUF(7, "DELeting control for: "
677 "cp.dst=%s:%d ctl_cp.dst=%s:%d\n",
678 IP_VS_DBG_ADDR(cp->af, &cp->caddr),
679 ntohs(cp->cport),
680 IP_VS_DBG_ADDR(cp->af, &ctl_cp->caddr),
681 ntohs(ctl_cp->cport));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682
683 cp->control = NULL;
684 if (atomic_read(&ctl_cp->n_control) == 0) {
Julius Volzcfc78c52008-09-02 15:55:53 +0200685 IP_VS_ERR_BUF("BUG control DEL with n=0 : "
686 "%s:%d to %s:%d\n",
687 IP_VS_DBG_ADDR(cp->af, &cp->caddr),
688 ntohs(cp->cport),
689 IP_VS_DBG_ADDR(cp->af, &cp->vaddr),
690 ntohs(cp->vport));
691
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 return;
693 }
694 atomic_dec(&ctl_cp->n_control);
695}
696
697static inline void
698ip_vs_control_add(struct ip_vs_conn *cp, struct ip_vs_conn *ctl_cp)
699{
700 if (cp->control) {
Julius Volzcfc78c52008-09-02 15:55:53 +0200701 IP_VS_ERR_BUF("request control ADD for already controlled: "
702 "%s:%d to %s:%d\n",
703 IP_VS_DBG_ADDR(cp->af, &cp->caddr),
704 ntohs(cp->cport),
705 IP_VS_DBG_ADDR(cp->af, &cp->vaddr),
706 ntohs(cp->vport));
707
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 ip_vs_control_del(cp);
709 }
710
Julius Volzcfc78c52008-09-02 15:55:53 +0200711 IP_VS_DBG_BUF(7, "ADDing control for: "
712 "cp.dst=%s:%d ctl_cp.dst=%s:%d\n",
713 IP_VS_DBG_ADDR(cp->af, &cp->caddr),
714 ntohs(cp->cport),
715 IP_VS_DBG_ADDR(cp->af, &ctl_cp->caddr),
716 ntohs(ctl_cp->cport));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
718 cp->control = ctl_cp;
719 atomic_inc(&ctl_cp->n_control);
720}
721
722
723/*
724 * IPVS application functions
725 * (from ip_vs_app.c)
726 */
727#define IP_VS_APP_MAX_PORTS 8
728extern int register_ip_vs_app(struct ip_vs_app *app);
729extern void unregister_ip_vs_app(struct ip_vs_app *app);
730extern int ip_vs_bind_app(struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
731extern void ip_vs_unbind_app(struct ip_vs_conn *cp);
732extern int
733register_ip_vs_app_inc(struct ip_vs_app *app, __u16 proto, __u16 port);
734extern int ip_vs_app_inc_get(struct ip_vs_app *inc);
735extern void ip_vs_app_inc_put(struct ip_vs_app *inc);
736
Herbert Xu3db05fe2007-10-15 00:53:15 -0700737extern int ip_vs_app_pkt_out(struct ip_vs_conn *, struct sk_buff *skb);
738extern int ip_vs_app_pkt_in(struct ip_vs_conn *, struct sk_buff *skb);
Al Virodd0fc662005-10-07 07:46:04 +0100739extern int ip_vs_skb_replace(struct sk_buff *skb, gfp_t pri,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 char *o_buf, int o_len, char *n_buf, int n_len);
741extern int ip_vs_app_init(void);
742extern void ip_vs_app_cleanup(void);
743
744
745/*
746 * IPVS protocol functions (from ip_vs_proto.c)
747 */
748extern int ip_vs_protocol_init(void);
749extern void ip_vs_protocol_cleanup(void);
750extern void ip_vs_protocol_timeout_change(int flags);
751extern int *ip_vs_create_timeout_table(int *table, int size);
752extern int
Jan Engelhardt36cbd3d2009-08-05 10:42:58 -0700753ip_vs_set_state_timeout(int *table, int num, const char *const *names,
754 const char *name, int to);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755extern void
756ip_vs_tcpudp_debug_packet(struct ip_vs_protocol *pp, const struct sk_buff *skb,
757 int offset, const char *msg);
758
759extern struct ip_vs_protocol ip_vs_protocol_tcp;
760extern struct ip_vs_protocol ip_vs_protocol_udp;
761extern struct ip_vs_protocol ip_vs_protocol_icmp;
762extern struct ip_vs_protocol ip_vs_protocol_esp;
763extern struct ip_vs_protocol ip_vs_protocol_ah;
Venkata Mohan Reddy2906f662010-02-18 12:31:05 +0100764extern struct ip_vs_protocol ip_vs_protocol_sctp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
766/*
767 * Registering/unregistering scheduler functions
768 * (from ip_vs_sched.c)
769 */
770extern int register_ip_vs_scheduler(struct ip_vs_scheduler *scheduler);
771extern int unregister_ip_vs_scheduler(struct ip_vs_scheduler *scheduler);
772extern int ip_vs_bind_scheduler(struct ip_vs_service *svc,
773 struct ip_vs_scheduler *scheduler);
774extern int ip_vs_unbind_scheduler(struct ip_vs_service *svc);
775extern struct ip_vs_scheduler *ip_vs_scheduler_get(const char *sched_name);
776extern void ip_vs_scheduler_put(struct ip_vs_scheduler *scheduler);
777extern struct ip_vs_conn *
778ip_vs_schedule(struct ip_vs_service *svc, const struct sk_buff *skb);
779extern int ip_vs_leave(struct ip_vs_service *svc, struct sk_buff *skb,
780 struct ip_vs_protocol *pp);
781
782
783/*
784 * IPVS control data and functions (from ip_vs_ctl.c)
785 */
786extern int sysctl_ip_vs_cache_bypass;
787extern int sysctl_ip_vs_expire_nodest_conn;
788extern int sysctl_ip_vs_expire_quiescent_template;
789extern int sysctl_ip_vs_sync_threshold[2];
790extern int sysctl_ip_vs_nat_icmp_send;
791extern struct ip_vs_stats ip_vs_stats;
Sven Wegener5587da52008-08-10 18:24:40 +0000792extern const struct ctl_path net_vs_ctl_path[];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
794extern struct ip_vs_service *
Julius Volz3c2e0502008-09-02 15:55:38 +0200795ip_vs_service_get(int af, __u32 fwmark, __u16 protocol,
796 const union nf_inet_addr *vaddr, __be16 vport);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
798static inline void ip_vs_service_put(struct ip_vs_service *svc)
799{
800 atomic_dec(&svc->usecnt);
801}
802
803extern struct ip_vs_dest *
Julius Volz7937df12008-09-02 15:55:48 +0200804ip_vs_lookup_real_service(int af, __u16 protocol,
805 const union nf_inet_addr *daddr, __be16 dport);
806
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807extern int ip_vs_use_count_inc(void);
808extern void ip_vs_use_count_dec(void);
809extern int ip_vs_control_init(void);
810extern void ip_vs_control_cleanup(void);
Rumen G. Bogdanovski1e356f92007-11-07 02:35:54 -0800811extern struct ip_vs_dest *
Julius Volz7937df12008-09-02 15:55:48 +0200812ip_vs_find_dest(int af, const union nf_inet_addr *daddr, __be16 dport,
813 const union nf_inet_addr *vaddr, __be16 vport, __u16 protocol);
Rumen G. Bogdanovski1e356f92007-11-07 02:35:54 -0800814extern struct ip_vs_dest *ip_vs_try_bind_dest(struct ip_vs_conn *cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815
816
817/*
818 * IPVS sync daemon data and function prototypes
819 * (from ip_vs_sync.c)
820 */
821extern volatile int ip_vs_sync_state;
822extern volatile int ip_vs_master_syncid;
823extern volatile int ip_vs_backup_syncid;
824extern char ip_vs_master_mcast_ifn[IP_VS_IFNAME_MAXLEN];
825extern char ip_vs_backup_mcast_ifn[IP_VS_IFNAME_MAXLEN];
826extern int start_sync_thread(int state, char *mcast_ifn, __u8 syncid);
827extern int stop_sync_thread(int state);
828extern void ip_vs_sync_conn(struct ip_vs_conn *cp);
829
830
831/*
832 * IPVS rate estimator prototypes (from ip_vs_est.c)
833 */
Sven Wegenera919cf42008-08-14 00:47:16 +0200834extern int ip_vs_estimator_init(void);
835extern void ip_vs_estimator_cleanup(void);
Sven Wegener3a14a3132008-08-10 18:24:41 +0000836extern void ip_vs_new_estimator(struct ip_vs_stats *stats);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837extern void ip_vs_kill_estimator(struct ip_vs_stats *stats);
838extern void ip_vs_zero_estimator(struct ip_vs_stats *stats);
839
840/*
841 * Various IPVS packet transmitters (from ip_vs_xmit.c)
842 */
843extern int ip_vs_null_xmit
844(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
845extern int ip_vs_bypass_xmit
846(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
847extern int ip_vs_nat_xmit
848(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
849extern int ip_vs_tunnel_xmit
850(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
851extern int ip_vs_dr_xmit
852(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
853extern int ip_vs_icmp_xmit
854(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, int offset);
855extern void ip_vs_dst_reset(struct ip_vs_dest *dest);
856
Julius Volzb3cdd2a72008-09-02 15:55:45 +0200857#ifdef CONFIG_IP_VS_IPV6
858extern int ip_vs_bypass_xmit_v6
859(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
860extern int ip_vs_nat_xmit_v6
861(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
862extern int ip_vs_tunnel_xmit_v6
863(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
864extern int ip_vs_dr_xmit_v6
865(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
866extern int ip_vs_icmp_xmit_v6
867(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp,
868 int offset);
869#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870
871/*
872 * This is a simple mechanism to ignore packets when
873 * we are loaded. Just set ip_vs_drop_rate to 'n' and
874 * we start to drop 1/rate of the packets
875 */
876extern int ip_vs_drop_rate;
877extern int ip_vs_drop_counter;
878
879static __inline__ int ip_vs_todrop(void)
880{
881 if (!ip_vs_drop_rate) return 0;
882 if (--ip_vs_drop_counter > 0) return 0;
883 ip_vs_drop_counter = ip_vs_drop_rate;
884 return 1;
885}
886
887/*
888 * ip_vs_fwd_tag returns the forwarding tag of the connection
889 */
890#define IP_VS_FWD_METHOD(cp) (cp->flags & IP_VS_CONN_F_FWD_MASK)
891
Adrian Bunk732db652005-09-01 17:40:26 -0700892static inline char ip_vs_fwd_tag(struct ip_vs_conn *cp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893{
894 char fwd;
895
896 switch (IP_VS_FWD_METHOD(cp)) {
897 case IP_VS_CONN_F_MASQ:
898 fwd = 'M'; break;
899 case IP_VS_CONN_F_LOCALNODE:
900 fwd = 'L'; break;
901 case IP_VS_CONN_F_TUNNEL:
902 fwd = 'T'; break;
903 case IP_VS_CONN_F_DROUTE:
904 fwd = 'R'; break;
905 case IP_VS_CONN_F_BYPASS:
906 fwd = 'B'; break;
907 default:
908 fwd = '?'; break;
909 }
910 return fwd;
911}
912
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913extern void ip_vs_nat_icmp(struct sk_buff *skb, struct ip_vs_protocol *pp,
Julius Volzb3cdd2a72008-09-02 15:55:45 +0200914 struct ip_vs_conn *cp, int dir);
915
916#ifdef CONFIG_IP_VS_IPV6
917extern void ip_vs_nat_icmp_v6(struct sk_buff *skb, struct ip_vs_protocol *pp,
918 struct ip_vs_conn *cp, int dir);
919#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920
Al Virob1550f22006-11-14 21:37:50 -0800921extern __sum16 ip_vs_checksum_complete(struct sk_buff *skb, int offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922
Al Virof9214b22006-11-16 02:41:18 -0800923static inline __wsum ip_vs_check_diff4(__be32 old, __be32 new, __wsum oldsum)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924{
Al Virof9214b22006-11-16 02:41:18 -0800925 __be32 diff[2] = { ~old, new };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926
Joe Perches07f07572008-11-19 15:44:53 -0800927 return csum_partial(diff, sizeof(diff), oldsum);
Al Virof9214b22006-11-16 02:41:18 -0800928}
929
Julius Volz0bbdd422008-09-02 15:55:42 +0200930#ifdef CONFIG_IP_VS_IPV6
931static inline __wsum ip_vs_check_diff16(const __be32 *old, const __be32 *new,
932 __wsum oldsum)
933{
934 __be32 diff[8] = { ~old[3], ~old[2], ~old[1], ~old[0],
935 new[3], new[2], new[1], new[0] };
936
Joe Perches07f07572008-11-19 15:44:53 -0800937 return csum_partial(diff, sizeof(diff), oldsum);
Julius Volz0bbdd422008-09-02 15:55:42 +0200938}
939#endif
940
Al Virof9214b22006-11-16 02:41:18 -0800941static inline __wsum ip_vs_check_diff2(__be16 old, __be16 new, __wsum oldsum)
942{
943 __be16 diff[2] = { ~old, new };
944
Joe Perches07f07572008-11-19 15:44:53 -0800945 return csum_partial(diff, sizeof(diff), oldsum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946}
947
948#endif /* __KERNEL__ */
949
Julius Volzbc4768e2008-07-31 20:45:24 -0700950#endif /* _NET_IP_VS_H */