net/netfilter/ipvs/ip_vs_proto.c

   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 <linux/stat.h>
  29 #include <linux/proc_fs.h>
  30
  31 #include <net/ip_vs.h>
  32
  33
  34 /*
  35  * IPVS protocols can only be registered/unregistered when the ipvs
  36  * module is loaded/unloaded, so no lock is needed in accessing the
  37  * ipvs protocol table.
  38  */
  39
  40 #define IP_VS_PROTO_TAB_SIZE            32      /* must be power of 2 */
  41 #define IP_VS_PROTO_HASH(proto)         ((proto) & (IP_VS_PROTO_TAB_SIZE-1))
  42
  43 static struct ip_vs_protocol *ip_vs_proto_table[IP_VS_PROTO_TAB_SIZE];
  44
  45
  46 /*
  47  *      register an ipvs protocol
  48  */
  49 static int __used __init register_ip_vs_protocol(struct ip_vs_protocol *pp)
  50 {
  51         unsigned int hash = IP_VS_PROTO_HASH(pp->protocol);
  52
  53         pp->next = ip_vs_proto_table[hash];
  54         ip_vs_proto_table[hash] = pp;
  55
  56         if (pp->init != NULL)
  57                 pp->init(pp);
  58
  59         return 0;
  60 }
  61
  62 /*
  63  *      register an ipvs protocols netns related data
  64  */
  65 static int
  66 register_ip_vs_proto_netns(struct net *net, struct ip_vs_protocol *pp)
  67 {
  68         struct netns_ipvs *ipvs = net_ipvs(net);
  69         unsigned int hash = IP_VS_PROTO_HASH(pp->protocol);
  70         struct ip_vs_proto_data *pd =
  71                         kzalloc(sizeof(struct ip_vs_proto_data), GFP_KERNEL);
  72
  73         if (!pd)
  74                 return -ENOMEM;
  75
  76         pd->pp = pp;    /* For speed issues */
  77         pd->next = ipvs->proto_data_table[hash];
  78         ipvs->proto_data_table[hash] = pd;
  79         atomic_set(&pd->appcnt, 0);     /* Init app counter */
  80
  81         if (pp->init_netns != NULL) {
  82                 int ret = pp->init_netns(net, pd);
  83                 if (ret) {
  84                         /* unlink an free proto data */
  85                         ipvs->proto_data_table[hash] = pd->next;
  86                         kfree(pd);
  87                         return ret;
  88                 }
  89         }
  90
  91         return 0;
  92 }
  93
  94 /*
  95  *      unregister an ipvs protocol
  96  */
  97 static int unregister_ip_vs_protocol(struct ip_vs_protocol *pp)
  98 {
  99         struct ip_vs_protocol **pp_p;
 100         unsigned int hash = IP_VS_PROTO_HASH(pp->protocol);
 101
 102         pp_p = &ip_vs_proto_table[hash];
 103         for (; *pp_p; pp_p = &(*pp_p)->next) {
 104                 if (*pp_p == pp) {
 105                         *pp_p = pp->next;
 106                         if (pp->exit != NULL)
 107                                 pp->exit(pp);
 108                         return 0;
 109                 }
 110         }
 111
 112         return -ESRCH;
 113 }
 114
 115 /*
 116  *      unregister an ipvs protocols netns data
 117  */
 118 static int
 119 unregister_ip_vs_proto_netns(struct net *net, struct ip_vs_proto_data *pd)
 120 {
 121         struct netns_ipvs *ipvs = net_ipvs(net);
 122         struct ip_vs_proto_data **pd_p;
 123         unsigned int hash = IP_VS_PROTO_HASH(pd->pp->protocol);
 124
 125         pd_p = &ipvs->proto_data_table[hash];
 126         for (; *pd_p; pd_p = &(*pd_p)->next) {
 127                 if (*pd_p == pd) {
 128                         *pd_p = pd->next;
 129                         if (pd->pp->exit_netns != NULL)
 130                                 pd->pp->exit_netns(net, pd);
 131                         kfree(pd);
 132                         return 0;
 133                 }
 134         }
 135
 136         return -ESRCH;
 137 }
 138
 139 /*
 140  *      get ip_vs_protocol object by its proto.
 141  */
 142 struct ip_vs_protocol * ip_vs_proto_get(unsigned short proto)
 143 {
 144         struct ip_vs_protocol *pp;
 145         unsigned int hash = IP_VS_PROTO_HASH(proto);
 146
 147         for (pp = ip_vs_proto_table[hash]; pp; pp = pp->next) {
 148                 if (pp->protocol == proto)
 149                         return pp;
 150         }
 151
 152         return NULL;
 153 }
 154 EXPORT_SYMBOL(ip_vs_proto_get);
 155
 156 /*
 157  *      get ip_vs_protocol object data by netns and proto
 158  */
 159 struct ip_vs_proto_data *
 160 __ipvs_proto_data_get(struct netns_ipvs *ipvs, unsigned short proto)
 161 {
 162         struct ip_vs_proto_data *pd;
 163         unsigned int hash = IP_VS_PROTO_HASH(proto);
 164
 165         for (pd = ipvs->proto_data_table[hash]; pd; pd = pd->next) {
 166                 if (pd->pp->protocol == proto)
 167                         return pd;
 168         }
 169
 170         return NULL;
 171 }
 172
 173 struct ip_vs_proto_data *
 174 ip_vs_proto_data_get(struct net *net, unsigned short proto)
 175 {
 176         struct netns_ipvs *ipvs = net_ipvs(net);
 177
 178         return __ipvs_proto_data_get(ipvs, proto);
 179 }
 180 EXPORT_SYMBOL(ip_vs_proto_data_get);
 181
 182 /*
 183  *      Propagate event for state change to all protocols
 184  */
 185 void ip_vs_protocol_timeout_change(struct netns_ipvs *ipvs, int flags)
 186 {
 187         struct ip_vs_proto_data *pd;
 188         int i;
 189
 190         for (i = 0; i < IP_VS_PROTO_TAB_SIZE; i++) {
 191                 for (pd = ipvs->proto_data_table[i]; pd; pd = pd->next) {
 192                         if (pd->pp->timeout_change)
 193                                 pd->pp->timeout_change(pd, flags);
 194                 }
 195         }
 196 }
 197
 198
 199 int *
 200 ip_vs_create_timeout_table(int *table, int size)
 201 {
 202         return kmemdup(table, size, GFP_KERNEL);
 203 }
 204
 205
 206 /*
 207  *      Set timeout value for state specified by name
 208  */
 209 int
 210 ip_vs_set_state_timeout(int *table, int num, const char *const *names,
 211                         const char *name, int to)
 212 {
 213         int i;
 214
 215         if (!table || !name || !to)
 216                 return -EINVAL;
 217
 218         for (i = 0; i < num; i++) {
 219                 if (strcmp(names[i], name))
 220                         continue;
 221                 table[i] = to * HZ;
 222                 return 0;
 223         }
 224         return -ENOENT;
 225 }
 226
 227
 228 const char * ip_vs_state_name(__u16 proto, int state)
 229 {
 230         struct ip_vs_protocol *pp = ip_vs_proto_get(proto);
 231
 232         if (pp == NULL || pp->state_name == NULL)
 233                 return (IPPROTO_IP == proto) ? "NONE" : "ERR!";
 234         return pp->state_name(state);
 235 }
 236
 237
 238 static void
 239 ip_vs_tcpudp_debug_packet_v4(struct ip_vs_protocol *pp,
 240                              const struct sk_buff *skb,
 241                              int offset,
 242                              const char *msg)
 243 {
 244         char buf[128];
 245         struct iphdr _iph, *ih;
 246
 247         ih = skb_header_pointer(skb, offset, sizeof(_iph), &_iph);
 248         if (ih == NULL)
 249                 sprintf(buf, "TRUNCATED");
 250         else if (ih->frag_off & htons(IP_OFFSET))
 251                 sprintf(buf, "%pI4->%pI4 frag", &ih->saddr, &ih->daddr);
 252         else {
 253                 __be16 _ports[2], *pptr;
 254
 255                 pptr = skb_header_pointer(skb, offset + ih->ihl*4,
 256                                           sizeof(_ports), _ports);
 257                 if (pptr == NULL)
 258                         sprintf(buf, "TRUNCATED %pI4->%pI4",
 259                                 &ih->saddr, &ih->daddr);
 260                 else
 261                         sprintf(buf, "%pI4:%u->%pI4:%u",
 262                                 &ih->saddr, ntohs(pptr[0]),
 263                                 &ih->daddr, ntohs(pptr[1]));
 264         }
 265
 266         pr_debug("%s: %s %s\n", msg, pp->name, buf);
 267 }
 268
 269 #ifdef CONFIG_IP_VS_IPV6
 270 static void
 271 ip_vs_tcpudp_debug_packet_v6(struct ip_vs_protocol *pp,
 272                              const struct sk_buff *skb,
 273                              int offset,
 274                              const char *msg)
 275 {
 276         char buf[192];
 277         struct ipv6hdr _iph, *ih;
 278
 279         ih = skb_header_pointer(skb, offset, sizeof(_iph), &_iph);
 280         if (ih == NULL)
 281                 sprintf(buf, "TRUNCATED");
 282         else if (ih->nexthdr == IPPROTO_FRAGMENT)
 283                 sprintf(buf, "%pI6->%pI6 frag", &ih->saddr, &ih->daddr);
 284         else {
 285                 __be16 _ports[2], *pptr;
 286
 287                 pptr = skb_header_pointer(skb, offset + sizeof(struct ipv6hdr),
 288                                           sizeof(_ports), _ports);
 289                 if (pptr == NULL)
 290                         sprintf(buf, "TRUNCATED %pI6->%pI6",
 291                                 &ih->saddr, &ih->daddr);
 292                 else
 293                         sprintf(buf, "%pI6:%u->%pI6:%u",
 294                                 &ih->saddr, ntohs(pptr[0]),
 295                                 &ih->daddr, ntohs(pptr[1]));
 296         }
 297
 298         pr_debug("%s: %s %s\n", msg, pp->name, buf);
 299 }
 300 #endif
 301
 302
 303 void
 304 ip_vs_tcpudp_debug_packet(int af, struct ip_vs_protocol *pp,
 305                           const struct sk_buff *skb,
 306                           int offset,
 307                           const char *msg)
 308 {
 309 #ifdef CONFIG_IP_VS_IPV6
 310         if (af == AF_INET6)
 311                 ip_vs_tcpudp_debug_packet_v6(pp, skb, offset, msg);
 312         else
 313 #endif
 314                 ip_vs_tcpudp_debug_packet_v4(pp, skb, offset, msg);
 315 }
 316
 317 /*
 318  * per network name-space init
 319  */
 320 int __net_init ip_vs_protocol_net_init(struct net *net)
 321 {
 322         int i, ret;
 323         static struct ip_vs_protocol *protos[] = {
 324 #ifdef CONFIG_IP_VS_PROTO_TCP
 325         &ip_vs_protocol_tcp,
 326 #endif
 327 #ifdef CONFIG_IP_VS_PROTO_UDP
 328         &ip_vs_protocol_udp,
 329 #endif
 330 #ifdef CONFIG_IP_VS_PROTO_SCTP
 331         &ip_vs_protocol_sctp,
 332 #endif
 333 #ifdef CONFIG_IP_VS_PROTO_AH
 334         &ip_vs_protocol_ah,
 335 #endif
 336 #ifdef CONFIG_IP_VS_PROTO_ESP
 337         &ip_vs_protocol_esp,
 338 #endif
 339         };
 340
 341         for (i = 0; i < ARRAY_SIZE(protos); i++) {
 342                 ret = register_ip_vs_proto_netns(net, protos[i]);
 343                 if (ret < 0)
 344                         goto cleanup;
 345         }
 346         return 0;
 347
 348 cleanup:
 349         ip_vs_protocol_net_cleanup(net);
 350         return ret;
 351 }
 352
 353 void __net_exit ip_vs_protocol_net_cleanup(struct net *net)
 354 {
 355         struct netns_ipvs *ipvs = net_ipvs(net);
 356         struct ip_vs_proto_data *pd;
 357         int i;
 358
 359         /* unregister all the ipvs proto data for this netns */
 360         for (i = 0; i < IP_VS_PROTO_TAB_SIZE; i++) {
 361                 while ((pd = ipvs->proto_data_table[i]) != NULL)
 362                         unregister_ip_vs_proto_netns(net, pd);
 363         }
 364 }
 365
 366 int __init ip_vs_protocol_init(void)
 367 {
 368         char protocols[64];
 369 #define REGISTER_PROTOCOL(p)                    \
 370         do {                                    \
 371                 register_ip_vs_protocol(p);     \
 372                 strcat(protocols, ", ");        \
 373                 strcat(protocols, (p)->name);   \
 374         } while (0)
 375
 376         protocols[0] = '\0';
 377         protocols[2] = '\0';
 378 #ifdef CONFIG_IP_VS_PROTO_TCP
 379         REGISTER_PROTOCOL(&ip_vs_protocol_tcp);
 380 #endif
 381 #ifdef CONFIG_IP_VS_PROTO_UDP
 382         REGISTER_PROTOCOL(&ip_vs_protocol_udp);
 383 #endif
 384 #ifdef CONFIG_IP_VS_PROTO_SCTP
 385         REGISTER_PROTOCOL(&ip_vs_protocol_sctp);
 386 #endif
 387 #ifdef CONFIG_IP_VS_PROTO_AH
 388         REGISTER_PROTOCOL(&ip_vs_protocol_ah);
 389 #endif
 390 #ifdef CONFIG_IP_VS_PROTO_ESP
 391         REGISTER_PROTOCOL(&ip_vs_protocol_esp);
 392 #endif
 393         pr_info("Registered protocols (%s)\n", &protocols[2]);
 394
 395         return 0;
 396 }
 397
 398
 399 void ip_vs_protocol_cleanup(void)
 400 {
 401         struct ip_vs_protocol *pp;
 402         int i;
 403
 404         /* unregister all the ipvs protocols */
 405         for (i = 0; i < IP_VS_PROTO_TAB_SIZE; i++) {
 406                 while ((pp = ip_vs_proto_table[i]) != NULL)
 407                         unregister_ip_vs_protocol(pp);
 408         }
 409 }