1 /* 2 * ip_vs_proto.c: transport protocol load balancing support for IPVS 3 * 4 * 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 #define KMSG_COMPONENT "IPVS" 17 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 18 19 #include <linux/module.h> 20 #include <linux/kernel.h> 21 #include <linux/skbuff.h> 22 #include <linux/gfp.h> 23 #include <linux/in.h> 24 #include <linux/ip.h> 25 #include <net/protocol.h> 26 #include <net/tcp.h> 27 #include <net/udp.h> 28 #include <asm/system.h> 29 #include <linux/stat.h> 30 #include <linux/proc_fs.h> 31 32 #include <net/ip_vs.h> 33 34 35 /* 36 * IPVS protocols can only be registered/unregistered when the ipvs 37 * module is loaded/unloaded, so no lock is needed in accessing the 38 * ipvs protocol table. 39 */ 40 41 #define IP_VS_PROTO_TAB_SIZE 32 /* must be power of 2 */ 42 #define IP_VS_PROTO_HASH(proto) ((proto) & (IP_VS_PROTO_TAB_SIZE-1)) 43 44 static struct ip_vs_protocol *ip_vs_proto_table[IP_VS_PROTO_TAB_SIZE]; 45 46 47 /* 48 * register an ipvs protocol 49 */ 50 static int __used __init register_ip_vs_protocol(struct ip_vs_protocol *pp) 51 { 52 unsigned hash = IP_VS_PROTO_HASH(pp->protocol); 53 54 pp->next = ip_vs_proto_table[hash]; 55 ip_vs_proto_table[hash] = pp; 56 57 if (pp->init != NULL) 58 pp->init(pp); 59 60 return 0; 61 } 62 63 64 /* 65 * unregister an ipvs protocol 66 */ 67 static int unregister_ip_vs_protocol(struct ip_vs_protocol *pp) 68 { 69 struct ip_vs_protocol **pp_p; 70 unsigned hash = IP_VS_PROTO_HASH(pp->protocol); 71 72 pp_p = &ip_vs_proto_table[hash]; 73 for (; *pp_p; pp_p = &(*pp_p)->next) { 74 if (*pp_p == pp) { 75 *pp_p = pp->next; 76 if (pp->exit != NULL) 77 pp->exit(pp); 78 return 0; 79 } 80 } 81 82 return -ESRCH; 83 } 84 85 86 /* 87 * get ip_vs_protocol object by its proto. 88 */ 89 struct ip_vs_protocol * ip_vs_proto_get(unsigned short proto) 90 { 91 struct ip_vs_protocol *pp; 92 unsigned hash = IP_VS_PROTO_HASH(proto); 93 94 for (pp = ip_vs_proto_table[hash]; pp; pp = pp->next) { 95 if (pp->protocol == proto) 96 return pp; 97 } 98 99 return NULL; 100 } 101 102 103 /* 104 * Propagate event for state change to all protocols 105 */ 106 void ip_vs_protocol_timeout_change(int flags) 107 { 108 struct ip_vs_protocol *pp; 109 int i; 110 111 for (i = 0; i < IP_VS_PROTO_TAB_SIZE; i++) { 112 for (pp = ip_vs_proto_table[i]; pp; pp = pp->next) { 113 if (pp->timeout_change) 114 pp->timeout_change(pp, flags); 115 } 116 } 117 } 118 119 120 int * 121 ip_vs_create_timeout_table(int *table, int size) 122 { 123 return kmemdup(table, size, GFP_ATOMIC); 124 } 125 126 127 /* 128 * Set timeout value for state specified by name 129 */ 130 int 131 ip_vs_set_state_timeout(int *table, int num, const char *const *names, 132 const char *name, int to) 133 { 134 int i; 135 136 if (!table || !name || !to) 137 return -EINVAL; 138 139 for (i = 0; i < num; i++) { 140 if (strcmp(names[i], name)) 141 continue; 142 table[i] = to * HZ; 143 return 0; 144 } 145 return -ENOENT; 146 } 147 148 149 const char * ip_vs_state_name(__u16 proto, int state) 150 { 151 struct ip_vs_protocol *pp = ip_vs_proto_get(proto); 152 153 if (pp == NULL || pp->state_name == NULL) 154 return (IPPROTO_IP == proto) ? "NONE" : "ERR!"; 155 return pp->state_name(state); 156 } 157 158 159 static void 160 ip_vs_tcpudp_debug_packet_v4(struct ip_vs_protocol *pp, 161 const struct sk_buff *skb, 162 int offset, 163 const char *msg) 164 { 165 char buf[128]; 166 struct iphdr _iph, *ih; 167 168 ih = skb_header_pointer(skb, offset, sizeof(_iph), &_iph); 169 if (ih == NULL) 170 sprintf(buf, "%s TRUNCATED", pp->name); 171 else if (ih->frag_off & htons(IP_OFFSET)) 172 sprintf(buf, "%s %pI4->%pI4 frag", 173 pp->name, &ih->saddr, &ih->daddr); 174 else { 175 __be16 _ports[2], *pptr 176 ; 177 pptr = skb_header_pointer(skb, offset + ih->ihl*4, 178 sizeof(_ports), _ports); 179 if (pptr == NULL) 180 sprintf(buf, "%s TRUNCATED %pI4->%pI4", 181 pp->name, &ih->saddr, &ih->daddr); 182 else 183 sprintf(buf, "%s %pI4:%u->%pI4:%u", 184 pp->name, 185 &ih->saddr, ntohs(pptr[0]), 186 &ih->daddr, ntohs(pptr[1])); 187 } 188 189 pr_debug("%s: %s\n", msg, buf); 190 } 191 192 #ifdef CONFIG_IP_VS_IPV6 193 static void 194 ip_vs_tcpudp_debug_packet_v6(struct ip_vs_protocol *pp, 195 const struct sk_buff *skb, 196 int offset, 197 const char *msg) 198 { 199 char buf[192]; 200 struct ipv6hdr _iph, *ih; 201 202 ih = skb_header_pointer(skb, offset, sizeof(_iph), &_iph); 203 if (ih == NULL) 204 sprintf(buf, "%s TRUNCATED", pp->name); 205 else if (ih->nexthdr == IPPROTO_FRAGMENT) 206 sprintf(buf, "%s %pI6->%pI6 frag", 207 pp->name, &ih->saddr, &ih->daddr); 208 else { 209 __be16 _ports[2], *pptr; 210 211 pptr = skb_header_pointer(skb, offset + sizeof(struct ipv6hdr), 212 sizeof(_ports), _ports); 213 if (pptr == NULL) 214 sprintf(buf, "%s TRUNCATED %pI6->%pI6", 215 pp->name, &ih->saddr, &ih->daddr); 216 else 217 sprintf(buf, "%s %pI6:%u->%pI6:%u", 218 pp->name, 219 &ih->saddr, ntohs(pptr[0]), 220 &ih->daddr, ntohs(pptr[1])); 221 } 222 223 pr_debug("%s: %s\n", msg, buf); 224 } 225 #endif 226 227 228 void 229 ip_vs_tcpudp_debug_packet(struct ip_vs_protocol *pp, 230 const struct sk_buff *skb, 231 int offset, 232 const char *msg) 233 { 234 #ifdef CONFIG_IP_VS_IPV6 235 if (skb->protocol == htons(ETH_P_IPV6)) 236 ip_vs_tcpudp_debug_packet_v6(pp, skb, offset, msg); 237 else 238 #endif 239 ip_vs_tcpudp_debug_packet_v4(pp, skb, offset, msg); 240 } 241 242 243 int __init ip_vs_protocol_init(void) 244 { 245 char protocols[64]; 246 #define REGISTER_PROTOCOL(p) \ 247 do { \ 248 register_ip_vs_protocol(p); \ 249 strcat(protocols, ", "); \ 250 strcat(protocols, (p)->name); \ 251 } while (0) 252 253 protocols[0] = '\0'; 254 protocols[2] = '\0'; 255 #ifdef CONFIG_IP_VS_PROTO_TCP 256 REGISTER_PROTOCOL(&ip_vs_protocol_tcp); 257 #endif 258 #ifdef CONFIG_IP_VS_PROTO_UDP 259 REGISTER_PROTOCOL(&ip_vs_protocol_udp); 260 #endif 261 #ifdef CONFIG_IP_VS_PROTO_SCTP 262 REGISTER_PROTOCOL(&ip_vs_protocol_sctp); 263 #endif 264 #ifdef CONFIG_IP_VS_PROTO_AH 265 REGISTER_PROTOCOL(&ip_vs_protocol_ah); 266 #endif 267 #ifdef CONFIG_IP_VS_PROTO_ESP 268 REGISTER_PROTOCOL(&ip_vs_protocol_esp); 269 #endif 270 pr_info("Registered protocols (%s)\n", &protocols[2]); 271 272 return 0; 273 } 274 275 276 void ip_vs_protocol_cleanup(void) 277 { 278 struct ip_vs_protocol *pp; 279 int i; 280 281 /* unregister all the ipvs protocols */ 282 for (i = 0; i < IP_VS_PROTO_TAB_SIZE; i++) { 283 while ((pp = ip_vs_proto_table[i]) != NULL) 284 unregister_ip_vs_protocol(pp); 285 } 286 } 287