blob: 876714f23d6514135ae4401cb1561f1e00684b4e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * ip_vs_proto.c: transport protocol load balancing support for IPVS
3 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * Authors: Wensong Zhang <wensong@linuxvirtualserver.org>
5 * Julian Anastasov <ja@ssi.bg>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 * Changes:
13 *
14 */
15
16#include <linux/module.h>
17#include <linux/kernel.h>
18#include <linux/skbuff.h>
19#include <linux/in.h>
20#include <linux/ip.h>
21#include <net/protocol.h>
22#include <net/tcp.h>
23#include <net/udp.h>
24#include <asm/system.h>
25#include <linux/stat.h>
26#include <linux/proc_fs.h>
27
28#include <net/ip_vs.h>
29
30
31/*
32 * IPVS protocols can only be registered/unregistered when the ipvs
33 * module is loaded/unloaded, so no lock is needed in accessing the
34 * ipvs protocol table.
35 */
36
37#define IP_VS_PROTO_TAB_SIZE 32 /* must be power of 2 */
38#define IP_VS_PROTO_HASH(proto) ((proto) & (IP_VS_PROTO_TAB_SIZE-1))
39
40static struct ip_vs_protocol *ip_vs_proto_table[IP_VS_PROTO_TAB_SIZE];
41
42
43/*
44 * register an ipvs protocol
45 */
Pavel Emelyanovd535a912007-11-20 17:44:01 -080046static int __used register_ip_vs_protocol(struct ip_vs_protocol *pp)
Linus Torvalds1da177e2005-04-16 15:20:36 -070047{
48 unsigned hash = IP_VS_PROTO_HASH(pp->protocol);
49
50 pp->next = ip_vs_proto_table[hash];
51 ip_vs_proto_table[hash] = pp;
52
53 if (pp->init != NULL)
54 pp->init(pp);
55
56 return 0;
57}
58
59
60/*
61 * unregister an ipvs protocol
62 */
63static int unregister_ip_vs_protocol(struct ip_vs_protocol *pp)
64{
65 struct ip_vs_protocol **pp_p;
66 unsigned hash = IP_VS_PROTO_HASH(pp->protocol);
67
68 pp_p = &ip_vs_proto_table[hash];
69 for (; *pp_p; pp_p = &(*pp_p)->next) {
70 if (*pp_p == pp) {
71 *pp_p = pp->next;
72 if (pp->exit != NULL)
73 pp->exit(pp);
74 return 0;
75 }
76 }
77
78 return -ESRCH;
79}
80
81
82/*
83 * get ip_vs_protocol object by its proto.
84 */
85struct ip_vs_protocol * ip_vs_proto_get(unsigned short proto)
86{
87 struct ip_vs_protocol *pp;
88 unsigned hash = IP_VS_PROTO_HASH(proto);
89
90 for (pp = ip_vs_proto_table[hash]; pp; pp = pp->next) {
91 if (pp->protocol == proto)
92 return pp;
93 }
94
95 return NULL;
96}
97
98
99/*
100 * Propagate event for state change to all protocols
101 */
102void ip_vs_protocol_timeout_change(int flags)
103{
104 struct ip_vs_protocol *pp;
105 int i;
106
107 for (i = 0; i < IP_VS_PROTO_TAB_SIZE; i++) {
108 for (pp = ip_vs_proto_table[i]; pp; pp = pp->next) {
109 if (pp->timeout_change)
110 pp->timeout_change(pp, flags);
111 }
112 }
113}
114
115
116int *
117ip_vs_create_timeout_table(int *table, int size)
118{
Arnaldo Carvalho de Melo8b2ed4b2006-11-21 01:17:18 -0200119 return kmemdup(table, size, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120}
121
122
123/*
124 * Set timeout value for state specified by name
125 */
126int
127ip_vs_set_state_timeout(int *table, int num, char **names, char *name, int to)
128{
129 int i;
130
131 if (!table || !name || !to)
132 return -EINVAL;
133
134 for (i = 0; i < num; i++) {
135 if (strcmp(names[i], name))
136 continue;
137 table[i] = to * HZ;
138 return 0;
139 }
140 return -ENOENT;
141}
142
143
144const char * ip_vs_state_name(__u16 proto, int state)
145{
146 struct ip_vs_protocol *pp = ip_vs_proto_get(proto);
147
148 if (pp == NULL || pp->state_name == NULL)
Julian Anastasov2ad17de2008-04-29 03:21:23 -0700149 return (IPPROTO_IP == proto) ? "NONE" : "ERR!";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 return pp->state_name(state);
151}
152
153
154void
155ip_vs_tcpudp_debug_packet(struct ip_vs_protocol *pp,
156 const struct sk_buff *skb,
157 int offset,
158 const char *msg)
159{
160 char buf[128];
161 struct iphdr _iph, *ih;
162
163 ih = skb_header_pointer(skb, offset, sizeof(_iph), &_iph);
164 if (ih == NULL)
165 sprintf(buf, "%s TRUNCATED", pp->name);
YOSHIFUJI Hideaki5661df72007-12-12 03:53:11 +0900166 else if (ih->frag_off & htons(IP_OFFSET))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 sprintf(buf, "%s %u.%u.%u.%u->%u.%u.%u.%u frag",
168 pp->name, NIPQUAD(ih->saddr),
169 NIPQUAD(ih->daddr));
170 else {
Al Viro014d7302006-09-28 14:29:52 -0700171 __be16 _ports[2], *pptr
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172;
173 pptr = skb_header_pointer(skb, offset + ih->ihl*4,
174 sizeof(_ports), _ports);
175 if (pptr == NULL)
176 sprintf(buf, "%s TRUNCATED %u.%u.%u.%u->%u.%u.%u.%u",
177 pp->name,
178 NIPQUAD(ih->saddr),
179 NIPQUAD(ih->daddr));
180 else
181 sprintf(buf, "%s %u.%u.%u.%u:%u->%u.%u.%u.%u:%u",
182 pp->name,
183 NIPQUAD(ih->saddr),
184 ntohs(pptr[0]),
185 NIPQUAD(ih->daddr),
186 ntohs(pptr[1]));
187 }
188
189 printk(KERN_DEBUG "IPVS: %s: %s\n", msg, buf);
190}
191
192
193int ip_vs_protocol_init(void)
194{
195 char protocols[64];
196#define REGISTER_PROTOCOL(p) \
197 do { \
198 register_ip_vs_protocol(p); \
199 strcat(protocols, ", "); \
200 strcat(protocols, (p)->name); \
201 } while (0)
202
203 protocols[0] = '\0';
204 protocols[2] = '\0';
205#ifdef CONFIG_IP_VS_PROTO_TCP
206 REGISTER_PROTOCOL(&ip_vs_protocol_tcp);
207#endif
208#ifdef CONFIG_IP_VS_PROTO_UDP
209 REGISTER_PROTOCOL(&ip_vs_protocol_udp);
210#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211#ifdef CONFIG_IP_VS_PROTO_AH
212 REGISTER_PROTOCOL(&ip_vs_protocol_ah);
213#endif
214#ifdef CONFIG_IP_VS_PROTO_ESP
215 REGISTER_PROTOCOL(&ip_vs_protocol_esp);
216#endif
217 IP_VS_INFO("Registered protocols (%s)\n", &protocols[2]);
218
219 return 0;
220}
221
222
223void ip_vs_protocol_cleanup(void)
224{
225 struct ip_vs_protocol *pp;
226 int i;
227
228 /* unregister all the ipvs protocols */
229 for (i = 0; i < IP_VS_PROTO_TAB_SIZE; i++) {
230 while ((pp = ip_vs_proto_table[i]) != NULL)
231 unregister_ip_vs_protocol(pp);
232 }
233}