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