Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 /* IP Virtual Server
0003  * data structure and functionality definitions
0004  */
0005 
0006 #ifndef _NET_IP_VS_H
0007 #define _NET_IP_VS_H
0008 
0009 #include <linux/ip_vs.h>                /* definitions shared with userland */
0010 
0011 #include <asm/types.h>                  /* for __uXX types */
0012 
0013 #include <linux/list.h>                 /* for struct list_head */
0014 #include <linux/spinlock.h>             /* for struct rwlock_t */
0015 #include <linux/atomic.h>               /* for struct atomic_t */
0016 #include <linux/refcount.h>             /* for struct refcount_t */
0017 #include <linux/workqueue.h>
0018 
0019 #include <linux/compiler.h>
0020 #include <linux/timer.h>
0021 #include <linux/bug.h>
0022 
0023 #include <net/checksum.h>
0024 #include <linux/netfilter.h>        /* for union nf_inet_addr */
0025 #include <linux/ip.h>
0026 #include <linux/ipv6.h>         /* for struct ipv6hdr */
0027 #include <net/ipv6.h>
0028 #if IS_ENABLED(CONFIG_NF_CONNTRACK)
0029 #include <net/netfilter/nf_conntrack.h>
0030 #endif
0031 #include <net/net_namespace.h>      /* Netw namespace */
0032 
0033 #define IP_VS_HDR_INVERSE   1
0034 #define IP_VS_HDR_ICMP      2
0035 
0036 /* Generic access of ipvs struct */
0037 static inline struct netns_ipvs *net_ipvs(struct net* net)
0038 {
0039     return net->ipvs;
0040 }
0041 
0042 /* Connections' size value needed by ip_vs_ctl.c */
0043 extern int ip_vs_conn_tab_size;
0044 
0045 struct ip_vs_iphdr {
0046     int hdr_flags;  /* ipvs flags */
0047     __u32 off;  /* Where IP or IPv4 header starts */
0048     __u32 len;  /* IPv4 simply where L4 starts
0049              * IPv6 where L4 Transport Header starts */
0050     __u16 fragoffs; /* IPv6 fragment offset, 0 if first frag (or not frag)*/
0051     __s16 protocol;
0052     __s32 flags;
0053     union nf_inet_addr saddr;
0054     union nf_inet_addr daddr;
0055 };
0056 
0057 static inline void *frag_safe_skb_hp(const struct sk_buff *skb, int offset,
0058                       int len, void *buffer)
0059 {
0060     return skb_header_pointer(skb, offset, len, buffer);
0061 }
0062 
0063 /* This function handles filling *ip_vs_iphdr, both for IPv4 and IPv6.
0064  * IPv6 requires some extra work, as finding proper header position,
0065  * depend on the IPv6 extension headers.
0066  */
0067 static inline int
0068 ip_vs_fill_iph_skb_off(int af, const struct sk_buff *skb, int offset,
0069                int hdr_flags, struct ip_vs_iphdr *iphdr)
0070 {
0071     iphdr->hdr_flags = hdr_flags;
0072     iphdr->off = offset;
0073 
0074 #ifdef CONFIG_IP_VS_IPV6
0075     if (af == AF_INET6) {
0076         struct ipv6hdr _iph;
0077         const struct ipv6hdr *iph = skb_header_pointer(
0078             skb, offset, sizeof(_iph), &_iph);
0079         if (!iph)
0080             return 0;
0081 
0082         iphdr->saddr.in6 = iph->saddr;
0083         iphdr->daddr.in6 = iph->daddr;
0084         /* ipv6_find_hdr() updates len, flags */
0085         iphdr->len   = offset;
0086         iphdr->flags     = 0;
0087         iphdr->protocol  = ipv6_find_hdr(skb, &iphdr->len, -1,
0088                          &iphdr->fragoffs,
0089                          &iphdr->flags);
0090         if (iphdr->protocol < 0)
0091             return 0;
0092     } else
0093 #endif
0094     {
0095         struct iphdr _iph;
0096         const struct iphdr *iph = skb_header_pointer(
0097             skb, offset, sizeof(_iph), &_iph);
0098         if (!iph)
0099             return 0;
0100 
0101         iphdr->len  = offset + iph->ihl * 4;
0102         iphdr->fragoffs = 0;
0103         iphdr->protocol = iph->protocol;
0104         iphdr->saddr.ip = iph->saddr;
0105         iphdr->daddr.ip = iph->daddr;
0106     }
0107 
0108     return 1;
0109 }
0110 
0111 static inline int
0112 ip_vs_fill_iph_skb_icmp(int af, const struct sk_buff *skb, int offset,
0113             bool inverse, struct ip_vs_iphdr *iphdr)
0114 {
0115     int hdr_flags = IP_VS_HDR_ICMP;
0116 
0117     if (inverse)
0118         hdr_flags |= IP_VS_HDR_INVERSE;
0119 
0120     return ip_vs_fill_iph_skb_off(af, skb, offset, hdr_flags, iphdr);
0121 }
0122 
0123 static inline int
0124 ip_vs_fill_iph_skb(int af, const struct sk_buff *skb, bool inverse,
0125            struct ip_vs_iphdr *iphdr)
0126 {
0127     int hdr_flags = 0;
0128 
0129     if (inverse)
0130         hdr_flags |= IP_VS_HDR_INVERSE;
0131 
0132     return ip_vs_fill_iph_skb_off(af, skb, skb_network_offset(skb),
0133                       hdr_flags, iphdr);
0134 }
0135 
0136 static inline bool
0137 ip_vs_iph_inverse(const struct ip_vs_iphdr *iph)
0138 {
0139     return !!(iph->hdr_flags & IP_VS_HDR_INVERSE);
0140 }
0141 
0142 static inline bool
0143 ip_vs_iph_icmp(const struct ip_vs_iphdr *iph)
0144 {
0145     return !!(iph->hdr_flags & IP_VS_HDR_ICMP);
0146 }
0147 
0148 static inline void ip_vs_addr_copy(int af, union nf_inet_addr *dst,
0149                    const union nf_inet_addr *src)
0150 {
0151 #ifdef CONFIG_IP_VS_IPV6
0152     if (af == AF_INET6)
0153         dst->in6 = src->in6;
0154     else
0155 #endif
0156     dst->ip = src->ip;
0157 }
0158 
0159 static inline void ip_vs_addr_set(int af, union nf_inet_addr *dst,
0160                   const union nf_inet_addr *src)
0161 {
0162 #ifdef CONFIG_IP_VS_IPV6
0163     if (af == AF_INET6) {
0164         dst->in6 = src->in6;
0165         return;
0166     }
0167 #endif
0168     dst->ip = src->ip;
0169     dst->all[1] = 0;
0170     dst->all[2] = 0;
0171     dst->all[3] = 0;
0172 }
0173 
0174 static inline int ip_vs_addr_equal(int af, const union nf_inet_addr *a,
0175                    const union nf_inet_addr *b)
0176 {
0177 #ifdef CONFIG_IP_VS_IPV6
0178     if (af == AF_INET6)
0179         return ipv6_addr_equal(&a->in6, &b->in6);
0180 #endif
0181     return a->ip == b->ip;
0182 }
0183 
0184 #ifdef CONFIG_IP_VS_DEBUG
0185 #include <linux/net.h>
0186 
0187 int ip_vs_get_debug_level(void);
0188 
0189 static inline const char *ip_vs_dbg_addr(int af, char *buf, size_t buf_len,
0190                      const union nf_inet_addr *addr,
0191                      int *idx)
0192 {
0193     int len;
0194 #ifdef CONFIG_IP_VS_IPV6
0195     if (af == AF_INET6)
0196         len = snprintf(&buf[*idx], buf_len - *idx, "[%pI6c]",
0197                    &addr->in6) + 1;
0198     else
0199 #endif
0200         len = snprintf(&buf[*idx], buf_len - *idx, "%pI4",
0201                    &addr->ip) + 1;
0202 
0203     *idx += len;
0204     BUG_ON(*idx > buf_len + 1);
0205     return &buf[*idx - len];
0206 }
0207 
0208 #define IP_VS_DBG_BUF(level, msg, ...)                  \
0209     do {                                \
0210         char ip_vs_dbg_buf[160];                \
0211         int ip_vs_dbg_idx = 0;                  \
0212         if (level <= ip_vs_get_debug_level())           \
0213             printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__);  \
0214     } while (0)
0215 #define IP_VS_ERR_BUF(msg...)                       \
0216     do {                                \
0217         char ip_vs_dbg_buf[160];                \
0218         int ip_vs_dbg_idx = 0;                  \
0219         pr_err(msg);                        \
0220     } while (0)
0221 
0222 /* Only use from within IP_VS_DBG_BUF() or IP_VS_ERR_BUF macros */
0223 #define IP_VS_DBG_ADDR(af, addr)                    \
0224     ip_vs_dbg_addr(af, ip_vs_dbg_buf,               \
0225                sizeof(ip_vs_dbg_buf), addr,         \
0226                &ip_vs_dbg_idx)
0227 
0228 #define IP_VS_DBG(level, msg, ...)                  \
0229     do {                                \
0230         if (level <= ip_vs_get_debug_level())           \
0231             printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__);  \
0232     } while (0)
0233 #define IP_VS_DBG_RL(msg, ...)                      \
0234     do {                                \
0235         if (net_ratelimit())                    \
0236             printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__);  \
0237     } while (0)
0238 #define IP_VS_DBG_PKT(level, af, pp, skb, ofs, msg)         \
0239     do {                                \
0240         if (level <= ip_vs_get_debug_level())           \
0241             pp->debug_packet(af, pp, skb, ofs, msg);    \
0242     } while (0)
0243 #define IP_VS_DBG_RL_PKT(level, af, pp, skb, ofs, msg)          \
0244     do {                                \
0245         if (level <= ip_vs_get_debug_level() &&         \
0246             net_ratelimit())                    \
0247             pp->debug_packet(af, pp, skb, ofs, msg);    \
0248     } while (0)
0249 #else   /* NO DEBUGGING at ALL */
0250 #define IP_VS_DBG_BUF(level, msg...)  do {} while (0)
0251 #define IP_VS_ERR_BUF(msg...)  do {} while (0)
0252 #define IP_VS_DBG(level, msg...)  do {} while (0)
0253 #define IP_VS_DBG_RL(msg...)  do {} while (0)
0254 #define IP_VS_DBG_PKT(level, af, pp, skb, ofs, msg) do {} while (0)
0255 #define IP_VS_DBG_RL_PKT(level, af, pp, skb, ofs, msg)  do {} while (0)
0256 #endif
0257 
0258 #define IP_VS_BUG() BUG()
0259 #define IP_VS_ERR_RL(msg, ...)                      \
0260     do {                                \
0261         if (net_ratelimit())                    \
0262             pr_err(msg, ##__VA_ARGS__);         \
0263     } while (0)
0264 
0265 #ifdef CONFIG_IP_VS_DEBUG
0266 #define EnterFunction(level)                        \
0267     do {                                \
0268         if (level <= ip_vs_get_debug_level())           \
0269             printk(KERN_DEBUG               \
0270                    pr_fmt("Enter: %s, %s line %i\n"),   \
0271                    __func__, __FILE__, __LINE__);       \
0272     } while (0)
0273 #define LeaveFunction(level)                        \
0274     do {                                \
0275         if (level <= ip_vs_get_debug_level())           \
0276             printk(KERN_DEBUG               \
0277                    pr_fmt("Leave: %s, %s line %i\n"),   \
0278                    __func__, __FILE__, __LINE__);       \
0279     } while (0)
0280 #else
0281 #define EnterFunction(level)   do {} while (0)
0282 #define LeaveFunction(level)   do {} while (0)
0283 #endif
0284 
0285 /* The port number of FTP service (in network order). */
0286 #define FTPPORT  cpu_to_be16(21)
0287 #define FTPDATA  cpu_to_be16(20)
0288 
0289 /* TCP State Values */
0290 enum {
0291     IP_VS_TCP_S_NONE = 0,
0292     IP_VS_TCP_S_ESTABLISHED,
0293     IP_VS_TCP_S_SYN_SENT,
0294     IP_VS_TCP_S_SYN_RECV,
0295     IP_VS_TCP_S_FIN_WAIT,
0296     IP_VS_TCP_S_TIME_WAIT,
0297     IP_VS_TCP_S_CLOSE,
0298     IP_VS_TCP_S_CLOSE_WAIT,
0299     IP_VS_TCP_S_LAST_ACK,
0300     IP_VS_TCP_S_LISTEN,
0301     IP_VS_TCP_S_SYNACK,
0302     IP_VS_TCP_S_LAST
0303 };
0304 
0305 /* UDP State Values */
0306 enum {
0307     IP_VS_UDP_S_NORMAL,
0308     IP_VS_UDP_S_LAST,
0309 };
0310 
0311 /* ICMP State Values */
0312 enum {
0313     IP_VS_ICMP_S_NORMAL,
0314     IP_VS_ICMP_S_LAST,
0315 };
0316 
0317 /* SCTP State Values */
0318 enum ip_vs_sctp_states {
0319     IP_VS_SCTP_S_NONE,
0320     IP_VS_SCTP_S_INIT1,
0321     IP_VS_SCTP_S_INIT,
0322     IP_VS_SCTP_S_COOKIE_SENT,
0323     IP_VS_SCTP_S_COOKIE_REPLIED,
0324     IP_VS_SCTP_S_COOKIE_WAIT,
0325     IP_VS_SCTP_S_COOKIE,
0326     IP_VS_SCTP_S_COOKIE_ECHOED,
0327     IP_VS_SCTP_S_ESTABLISHED,
0328     IP_VS_SCTP_S_SHUTDOWN_SENT,
0329     IP_VS_SCTP_S_SHUTDOWN_RECEIVED,
0330     IP_VS_SCTP_S_SHUTDOWN_ACK_SENT,
0331     IP_VS_SCTP_S_REJECTED,
0332     IP_VS_SCTP_S_CLOSED,
0333     IP_VS_SCTP_S_LAST
0334 };
0335 
0336 /* Connection templates use bits from state */
0337 #define IP_VS_CTPL_S_NONE       0x0000
0338 #define IP_VS_CTPL_S_ASSURED        0x0001
0339 #define IP_VS_CTPL_S_LAST       0x0002
0340 
0341 /* Delta sequence info structure
0342  * Each ip_vs_conn has 2 (output AND input seq. changes).
0343  * Only used in the VS/NAT.
0344  */
0345 struct ip_vs_seq {
0346     __u32           init_seq;   /* Add delta from this seq */
0347     __u32           delta;      /* Delta in sequence numbers */
0348     __u32           previous_delta; /* Delta in sequence numbers
0349                          * before last resized pkt */
0350 };
0351 
0352 /* counters per cpu */
0353 struct ip_vs_counters {
0354     __u64       conns;      /* connections scheduled */
0355     __u64       inpkts;     /* incoming packets */
0356     __u64       outpkts;    /* outgoing packets */
0357     __u64       inbytes;    /* incoming bytes */
0358     __u64       outbytes;   /* outgoing bytes */
0359 };
0360 /* Stats per cpu */
0361 struct ip_vs_cpu_stats {
0362     struct ip_vs_counters   cnt;
0363     struct u64_stats_sync   syncp;
0364 };
0365 
0366 /* IPVS statistics objects */
0367 struct ip_vs_estimator {
0368     struct list_head    list;
0369 
0370     u64         last_inbytes;
0371     u64         last_outbytes;
0372     u64         last_conns;
0373     u64         last_inpkts;
0374     u64         last_outpkts;
0375 
0376     u64         cps;
0377     u64         inpps;
0378     u64         outpps;
0379     u64         inbps;
0380     u64         outbps;
0381 };
0382 
0383 /*
0384  * IPVS statistics object, 64-bit kernel version of struct ip_vs_stats_user
0385  */
0386 struct ip_vs_kstats {
0387     u64         conns;      /* connections scheduled */
0388     u64         inpkts;     /* incoming packets */
0389     u64         outpkts;    /* outgoing packets */
0390     u64         inbytes;    /* incoming bytes */
0391     u64         outbytes;   /* outgoing bytes */
0392 
0393     u64         cps;        /* current connection rate */
0394     u64         inpps;      /* current in packet rate */
0395     u64         outpps;     /* current out packet rate */
0396     u64         inbps;      /* current in byte rate */
0397     u64         outbps;     /* current out byte rate */
0398 };
0399 
0400 struct ip_vs_stats {
0401     struct ip_vs_kstats kstats;     /* kernel statistics */
0402     struct ip_vs_estimator  est;        /* estimator */
0403     struct ip_vs_cpu_stats __percpu *cpustats;  /* per cpu counters */
0404     spinlock_t      lock;       /* spin lock */
0405     struct ip_vs_kstats kstats0;    /* reset values */
0406 };
0407 
0408 struct dst_entry;
0409 struct iphdr;
0410 struct ip_vs_conn;
0411 struct ip_vs_app;
0412 struct sk_buff;
0413 struct ip_vs_proto_data;
0414 
0415 struct ip_vs_protocol {
0416     struct ip_vs_protocol   *next;
0417     char            *name;
0418     u16         protocol;
0419     u16         num_states;
0420     int         dont_defrag;
0421 
0422     void (*init)(struct ip_vs_protocol *pp);
0423 
0424     void (*exit)(struct ip_vs_protocol *pp);
0425 
0426     int (*init_netns)(struct netns_ipvs *ipvs, struct ip_vs_proto_data *pd);
0427 
0428     void (*exit_netns)(struct netns_ipvs *ipvs, struct ip_vs_proto_data *pd);
0429 
0430     int (*conn_schedule)(struct netns_ipvs *ipvs,
0431                  int af, struct sk_buff *skb,
0432                  struct ip_vs_proto_data *pd,
0433                  int *verdict, struct ip_vs_conn **cpp,
0434                  struct ip_vs_iphdr *iph);
0435 
0436     struct ip_vs_conn *
0437     (*conn_in_get)(struct netns_ipvs *ipvs,
0438                int af,
0439                const struct sk_buff *skb,
0440                const struct ip_vs_iphdr *iph);
0441 
0442     struct ip_vs_conn *
0443     (*conn_out_get)(struct netns_ipvs *ipvs,
0444             int af,
0445             const struct sk_buff *skb,
0446             const struct ip_vs_iphdr *iph);
0447 
0448     int (*snat_handler)(struct sk_buff *skb, struct ip_vs_protocol *pp,
0449                 struct ip_vs_conn *cp, struct ip_vs_iphdr *iph);
0450 
0451     int (*dnat_handler)(struct sk_buff *skb, struct ip_vs_protocol *pp,
0452                 struct ip_vs_conn *cp, struct ip_vs_iphdr *iph);
0453 
0454     const char *(*state_name)(int state);
0455 
0456     void (*state_transition)(struct ip_vs_conn *cp, int direction,
0457                  const struct sk_buff *skb,
0458                  struct ip_vs_proto_data *pd);
0459 
0460     int (*register_app)(struct netns_ipvs *ipvs, struct ip_vs_app *inc);
0461 
0462     void (*unregister_app)(struct netns_ipvs *ipvs, struct ip_vs_app *inc);
0463 
0464     int (*app_conn_bind)(struct ip_vs_conn *cp);
0465 
0466     void (*debug_packet)(int af, struct ip_vs_protocol *pp,
0467                  const struct sk_buff *skb,
0468                  int offset,
0469                  const char *msg);
0470 
0471     void (*timeout_change)(struct ip_vs_proto_data *pd, int flags);
0472 };
0473 
0474 /* protocol data per netns */
0475 struct ip_vs_proto_data {
0476     struct ip_vs_proto_data *next;
0477     struct ip_vs_protocol   *pp;
0478     int         *timeout_table; /* protocol timeout table */
0479     atomic_t        appcnt;     /* counter of proto app incs. */
0480     struct tcp_states_t *tcp_state_table;
0481 };
0482 
0483 struct ip_vs_protocol   *ip_vs_proto_get(unsigned short proto);
0484 struct ip_vs_proto_data *ip_vs_proto_data_get(struct netns_ipvs *ipvs,
0485                           unsigned short proto);
0486 
0487 struct ip_vs_conn_param {
0488     struct netns_ipvs       *ipvs;
0489     const union nf_inet_addr    *caddr;
0490     const union nf_inet_addr    *vaddr;
0491     __be16              cport;
0492     __be16              vport;
0493     __u16               protocol;
0494     u16             af;
0495 
0496     const struct ip_vs_pe       *pe;
0497     char                *pe_data;
0498     __u8                pe_data_len;
0499 };
0500 
0501 /* IP_VS structure allocated for each dynamically scheduled connection */
0502 struct ip_vs_conn {
0503     struct hlist_node   c_list;         /* hashed list heads */
0504     /* Protocol, addresses and port numbers */
0505     __be16                  cport;
0506     __be16                  dport;
0507     __be16                  vport;
0508     u16         af;     /* address family */
0509     union nf_inet_addr      caddr;          /* client address */
0510     union nf_inet_addr      vaddr;          /* virtual address */
0511     union nf_inet_addr      daddr;          /* destination address */
0512     volatile __u32          flags;          /* status flags */
0513     __u16                   protocol;       /* Which protocol (TCP/UDP) */
0514     __u16           daf;        /* Address family of the dest */
0515     struct netns_ipvs   *ipvs;
0516 
0517     /* counter and timer */
0518     refcount_t      refcnt;     /* reference count */
0519     struct timer_list   timer;      /* Expiration timer */
0520     volatile unsigned long  timeout;    /* timeout */
0521 
0522     /* Flags and state transition */
0523     spinlock_t              lock;           /* lock for state transition */
0524     volatile __u16          state;          /* state info */
0525     volatile __u16          old_state;      /* old state, to be used for
0526                          * state transition triggerd
0527                          * synchronization
0528                          */
0529     __u32           fwmark;     /* Fire wall mark from skb */
0530     unsigned long       sync_endtime;   /* jiffies + sent_retries */
0531 
0532     /* Control members */
0533     struct ip_vs_conn       *control;       /* Master control connection */
0534     atomic_t                n_control;      /* Number of controlled ones */
0535     struct ip_vs_dest       *dest;          /* real server */
0536     atomic_t                in_pkts;        /* incoming packet counter */
0537 
0538     /* Packet transmitter for different forwarding methods.  If it
0539      * mangles the packet, it must return NF_DROP or better NF_STOLEN,
0540      * otherwise this must be changed to a sk_buff **.
0541      * NF_ACCEPT can be returned when destination is local.
0542      */
0543     int (*packet_xmit)(struct sk_buff *skb, struct ip_vs_conn *cp,
0544                struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
0545 
0546     /* Note: we can group the following members into a structure,
0547      * in order to save more space, and the following members are
0548      * only used in VS/NAT anyway
0549      */
0550     struct ip_vs_app        *app;           /* bound ip_vs_app object */
0551     void                    *app_data;      /* Application private data */
0552     struct ip_vs_seq        in_seq;         /* incoming seq. struct */
0553     struct ip_vs_seq        out_seq;        /* outgoing seq. struct */
0554 
0555     const struct ip_vs_pe   *pe;
0556     char            *pe_data;
0557     __u8            pe_data_len;
0558 
0559     struct rcu_head     rcu_head;
0560 };
0561 
0562 /* Extended internal versions of struct ip_vs_service_user and ip_vs_dest_user
0563  * for IPv6 support.
0564  *
0565  * We need these to conveniently pass around service and destination
0566  * options, but unfortunately, we also need to keep the old definitions to
0567  * maintain userspace backwards compatibility for the setsockopt interface.
0568  */
0569 struct ip_vs_service_user_kern {
0570     /* virtual service addresses */
0571     u16         af;
0572     u16         protocol;
0573     union nf_inet_addr  addr;       /* virtual ip address */
0574     __be16          port;
0575     u32         fwmark;     /* firwall mark of service */
0576 
0577     /* virtual service options */
0578     char            *sched_name;
0579     char            *pe_name;
0580     unsigned int        flags;      /* virtual service flags */
0581     unsigned int        timeout;    /* persistent timeout in sec */
0582     __be32          netmask;    /* persistent netmask or plen */
0583 };
0584 
0585 
0586 struct ip_vs_dest_user_kern {
0587     /* destination server address */
0588     union nf_inet_addr  addr;
0589     __be16          port;
0590 
0591     /* real server options */
0592     unsigned int        conn_flags; /* connection flags */
0593     int         weight;     /* destination weight */
0594 
0595     /* thresholds for active connections */
0596     u32         u_threshold;    /* upper threshold */
0597     u32         l_threshold;    /* lower threshold */
0598 
0599     /* Address family of addr */
0600     u16         af;
0601 
0602     u16         tun_type;   /* tunnel type */
0603     __be16          tun_port;   /* tunnel port */
0604     u16         tun_flags;  /* tunnel flags */
0605 };
0606 
0607 
0608 /*
0609  * The information about the virtual service offered to the net and the
0610  * forwarding entries.
0611  */
0612 struct ip_vs_service {
0613     struct hlist_node   s_list;   /* for normal service table */
0614     struct hlist_node   f_list;   /* for fwmark-based service table */
0615     atomic_t        refcnt;   /* reference counter */
0616 
0617     u16         af;       /* address family */
0618     __u16           protocol; /* which protocol (TCP/UDP) */
0619     union nf_inet_addr  addr;     /* IP address for virtual service */
0620     __be16          port;     /* port number for the service */
0621     __u32                   fwmark;   /* firewall mark of the service */
0622     unsigned int        flags;    /* service status flags */
0623     unsigned int        timeout;  /* persistent timeout in ticks */
0624     __be32          netmask;  /* grouping granularity, mask/plen */
0625     struct netns_ipvs   *ipvs;
0626 
0627     struct list_head    destinations;  /* real server d-linked list */
0628     __u32           num_dests;     /* number of servers */
0629     struct ip_vs_stats      stats;         /* statistics for the service */
0630 
0631     /* for scheduling */
0632     struct ip_vs_scheduler __rcu *scheduler; /* bound scheduler object */
0633     spinlock_t      sched_lock;    /* lock sched_data */
0634     void            *sched_data;   /* scheduler application data */
0635 
0636     /* alternate persistence engine */
0637     struct ip_vs_pe __rcu   *pe;
0638     int         conntrack_afmask;
0639 
0640     struct rcu_head     rcu_head;
0641 };
0642 
0643 /* Information for cached dst */
0644 struct ip_vs_dest_dst {
0645     struct dst_entry    *dst_cache; /* destination cache entry */
0646     u32         dst_cookie;
0647     union nf_inet_addr  dst_saddr;
0648     struct rcu_head     rcu_head;
0649 };
0650 
0651 /* The real server destination forwarding entry with ip address, port number,
0652  * and so on.
0653  */
0654 struct ip_vs_dest {
0655     struct list_head    n_list;   /* for the dests in the service */
0656     struct hlist_node   d_list;   /* for table with all the dests */
0657 
0658     u16         af;     /* address family */
0659     __be16          port;       /* port number of the server */
0660     union nf_inet_addr  addr;       /* IP address of the server */
0661     volatile unsigned int   flags;      /* dest status flags */
0662     atomic_t        conn_flags; /* flags to copy to conn */
0663     atomic_t        weight;     /* server weight */
0664     atomic_t        last_weight;    /* server latest weight */
0665     __u16           tun_type;   /* tunnel type */
0666     __be16          tun_port;   /* tunnel port */
0667     __u16           tun_flags;  /* tunnel flags */
0668 
0669     refcount_t      refcnt;     /* reference counter */
0670     struct ip_vs_stats      stats;          /* statistics */
0671     unsigned long       idle_start; /* start time, jiffies */
0672 
0673     /* connection counters and thresholds */
0674     atomic_t        activeconns;    /* active connections */
0675     atomic_t        inactconns; /* inactive connections */
0676     atomic_t        persistconns;   /* persistent connections */
0677     __u32           u_threshold;    /* upper threshold */
0678     __u32           l_threshold;    /* lower threshold */
0679 
0680     /* for destination cache */
0681     spinlock_t      dst_lock;   /* lock of dst_cache */
0682     struct ip_vs_dest_dst __rcu *dest_dst;  /* cached dst info */
0683 
0684     /* for virtual service */
0685     struct ip_vs_service __rcu *svc;    /* service it belongs to */
0686     __u16           protocol;   /* which protocol (TCP/UDP) */
0687     __be16          vport;      /* virtual port number */
0688     union nf_inet_addr  vaddr;      /* virtual IP address */
0689     __u32           vfwmark;    /* firewall mark of service */
0690 
0691     struct list_head    t_list;     /* in dest_trash */
0692     unsigned int        in_rs_table:1;  /* we are in rs_table */
0693 };
0694 
0695 /* The scheduler object */
0696 struct ip_vs_scheduler {
0697     struct list_head    n_list;     /* d-linked list head */
0698     char            *name;      /* scheduler name */
0699     atomic_t        refcnt;     /* reference counter */
0700     struct module       *module;    /* THIS_MODULE/NULL */
0701 
0702     /* scheduler initializing service */
0703     int (*init_service)(struct ip_vs_service *svc);
0704     /* scheduling service finish */
0705     void (*done_service)(struct ip_vs_service *svc);
0706     /* dest is linked */
0707     int (*add_dest)(struct ip_vs_service *svc, struct ip_vs_dest *dest);
0708     /* dest is unlinked */
0709     int (*del_dest)(struct ip_vs_service *svc, struct ip_vs_dest *dest);
0710     /* dest is updated */
0711     int (*upd_dest)(struct ip_vs_service *svc, struct ip_vs_dest *dest);
0712 
0713     /* selecting a server from the given service */
0714     struct ip_vs_dest* (*schedule)(struct ip_vs_service *svc,
0715                        const struct sk_buff *skb,
0716                        struct ip_vs_iphdr *iph);
0717 };
0718 
0719 /* The persistence engine object */
0720 struct ip_vs_pe {
0721     struct list_head    n_list;     /* d-linked list head */
0722     char            *name;      /* scheduler name */
0723     atomic_t        refcnt;     /* reference counter */
0724     struct module       *module;    /* THIS_MODULE/NULL */
0725 
0726     /* get the connection template, if any */
0727     int (*fill_param)(struct ip_vs_conn_param *p, struct sk_buff *skb);
0728     bool (*ct_match)(const struct ip_vs_conn_param *p,
0729              struct ip_vs_conn *ct);
0730     u32 (*hashkey_raw)(const struct ip_vs_conn_param *p, u32 initval,
0731                bool inverse);
0732     int (*show_pe_data)(const struct ip_vs_conn *cp, char *buf);
0733     /* create connections for real-server outgoing packets */
0734     struct ip_vs_conn* (*conn_out)(struct ip_vs_service *svc,
0735                        struct ip_vs_dest *dest,
0736                        struct sk_buff *skb,
0737                        const struct ip_vs_iphdr *iph,
0738                        __be16 dport, __be16 cport);
0739 };
0740 
0741 /* The application module object (a.k.a. app incarnation) */
0742 struct ip_vs_app {
0743     struct list_head    a_list;     /* member in app list */
0744     int         type;       /* IP_VS_APP_TYPE_xxx */
0745     char            *name;      /* application module name */
0746     __u16           protocol;
0747     struct module       *module;    /* THIS_MODULE/NULL */
0748     struct list_head    incs_list;  /* list of incarnations */
0749 
0750     /* members for application incarnations */
0751     struct list_head    p_list;     /* member in proto app list */
0752     struct ip_vs_app    *app;       /* its real application */
0753     __be16          port;       /* port number in net order */
0754     atomic_t        usecnt;     /* usage counter */
0755     struct rcu_head     rcu_head;
0756 
0757     /* output hook: Process packet in inout direction, diff set for TCP.
0758      * Return: 0=Error, 1=Payload Not Mangled/Mangled but checksum is ok,
0759      *     2=Mangled but checksum was not updated
0760      */
0761     int (*pkt_out)(struct ip_vs_app *, struct ip_vs_conn *,
0762                struct sk_buff *, int *diff, struct ip_vs_iphdr *ipvsh);
0763 
0764     /* input hook: Process packet in outin direction, diff set for TCP.
0765      * Return: 0=Error, 1=Payload Not Mangled/Mangled but checksum is ok,
0766      *     2=Mangled but checksum was not updated
0767      */
0768     int (*pkt_in)(struct ip_vs_app *, struct ip_vs_conn *,
0769               struct sk_buff *, int *diff, struct ip_vs_iphdr *ipvsh);
0770 
0771     /* ip_vs_app initializer */
0772     int (*init_conn)(struct ip_vs_app *, struct ip_vs_conn *);
0773 
0774     /* ip_vs_app finish */
0775     int (*done_conn)(struct ip_vs_app *, struct ip_vs_conn *);
0776 
0777 
0778     /* not used now */
0779     int (*bind_conn)(struct ip_vs_app *, struct ip_vs_conn *,
0780              struct ip_vs_protocol *);
0781 
0782     void (*unbind_conn)(struct ip_vs_app *, struct ip_vs_conn *);
0783 
0784     int *           timeout_table;
0785     int *           timeouts;
0786     int         timeouts_size;
0787 
0788     int (*conn_schedule)(struct sk_buff *skb, struct ip_vs_app *app,
0789                  int *verdict, struct ip_vs_conn **cpp);
0790 
0791     struct ip_vs_conn *
0792     (*conn_in_get)(const struct sk_buff *skb, struct ip_vs_app *app,
0793                const struct iphdr *iph, int inverse);
0794 
0795     struct ip_vs_conn *
0796     (*conn_out_get)(const struct sk_buff *skb, struct ip_vs_app *app,
0797             const struct iphdr *iph, int inverse);
0798 
0799     int (*state_transition)(struct ip_vs_conn *cp, int direction,
0800                 const struct sk_buff *skb,
0801                 struct ip_vs_app *app);
0802 
0803     void (*timeout_change)(struct ip_vs_app *app, int flags);
0804 };
0805 
0806 struct ipvs_master_sync_state {
0807     struct list_head    sync_queue;
0808     struct ip_vs_sync_buff  *sync_buff;
0809     unsigned long       sync_queue_len;
0810     unsigned int        sync_queue_delay;
0811     struct delayed_work master_wakeup_work;
0812     struct netns_ipvs   *ipvs;
0813 };
0814 
0815 struct ip_vs_sync_thread_data;
0816 
0817 /* How much time to keep dests in trash */
0818 #define IP_VS_DEST_TRASH_PERIOD     (120 * HZ)
0819 
0820 struct ipvs_sync_daemon_cfg {
0821     union nf_inet_addr  mcast_group;
0822     int         syncid;
0823     u16         sync_maxlen;
0824     u16         mcast_port;
0825     u8          mcast_af;
0826     u8          mcast_ttl;
0827     /* multicast interface name */
0828     char            mcast_ifn[IP_VS_IFNAME_MAXLEN];
0829 };
0830 
0831 /* IPVS in network namespace */
0832 struct netns_ipvs {
0833     int         gen;        /* Generation */
0834     int         enable;     /* enable like nf_hooks do */
0835     /* Hash table: for real service lookups */
0836     #define IP_VS_RTAB_BITS 4
0837     #define IP_VS_RTAB_SIZE (1 << IP_VS_RTAB_BITS)
0838     #define IP_VS_RTAB_MASK (IP_VS_RTAB_SIZE - 1)
0839 
0840     struct hlist_head   rs_table[IP_VS_RTAB_SIZE];
0841     /* ip_vs_app */
0842     struct list_head    app_list;
0843     /* ip_vs_proto */
0844     #define IP_VS_PROTO_TAB_SIZE    32  /* must be power of 2 */
0845     struct ip_vs_proto_data *proto_data_table[IP_VS_PROTO_TAB_SIZE];
0846     /* ip_vs_proto_tcp */
0847 #ifdef CONFIG_IP_VS_PROTO_TCP
0848     #define TCP_APP_TAB_BITS    4
0849     #define TCP_APP_TAB_SIZE    (1 << TCP_APP_TAB_BITS)
0850     #define TCP_APP_TAB_MASK    (TCP_APP_TAB_SIZE - 1)
0851     struct list_head    tcp_apps[TCP_APP_TAB_SIZE];
0852 #endif
0853     /* ip_vs_proto_udp */
0854 #ifdef CONFIG_IP_VS_PROTO_UDP
0855     #define UDP_APP_TAB_BITS    4
0856     #define UDP_APP_TAB_SIZE    (1 << UDP_APP_TAB_BITS)
0857     #define UDP_APP_TAB_MASK    (UDP_APP_TAB_SIZE - 1)
0858     struct list_head    udp_apps[UDP_APP_TAB_SIZE];
0859 #endif
0860     /* ip_vs_proto_sctp */
0861 #ifdef CONFIG_IP_VS_PROTO_SCTP
0862     #define SCTP_APP_TAB_BITS   4
0863     #define SCTP_APP_TAB_SIZE   (1 << SCTP_APP_TAB_BITS)
0864     #define SCTP_APP_TAB_MASK   (SCTP_APP_TAB_SIZE - 1)
0865     /* Hash table for SCTP application incarnations  */
0866     struct list_head    sctp_apps[SCTP_APP_TAB_SIZE];
0867 #endif
0868     /* ip_vs_conn */
0869     atomic_t        conn_count;      /* connection counter */
0870 
0871     /* ip_vs_ctl */
0872     struct ip_vs_stats      tot_stats;  /* Statistics & est. */
0873 
0874     int         num_services;    /* no of virtual services */
0875     int         num_services6;   /* IPv6 virtual services */
0876 
0877     /* Trash for destinations */
0878     struct list_head    dest_trash;
0879     spinlock_t      dest_trash_lock;
0880     struct timer_list   dest_trash_timer; /* expiration timer */
0881     /* Service counters */
0882     atomic_t        ftpsvc_counter;
0883     atomic_t        nullsvc_counter;
0884     atomic_t        conn_out_counter;
0885 
0886 #ifdef CONFIG_SYSCTL
0887     /* delayed work for expiring no dest connections */
0888     struct delayed_work expire_nodest_conn_work;
0889     /* 1/rate drop and drop-entry variables */
0890     struct delayed_work defense_work;   /* Work handler */
0891     int         drop_rate;
0892     int         drop_counter;
0893     int         old_secure_tcp;
0894     atomic_t        dropentry;
0895     /* locks in ctl.c */
0896     spinlock_t      dropentry_lock;  /* drop entry handling */
0897     spinlock_t      droppacket_lock; /* drop packet handling */
0898     spinlock_t      securetcp_lock;  /* state and timeout tables */
0899 
0900     /* sys-ctl struct */
0901     struct ctl_table_header *sysctl_hdr;
0902     struct ctl_table    *sysctl_tbl;
0903 #endif
0904 
0905     /* sysctl variables */
0906     int         sysctl_amemthresh;
0907     int         sysctl_am_droprate;
0908     int         sysctl_drop_entry;
0909     int         sysctl_drop_packet;
0910     int         sysctl_secure_tcp;
0911 #ifdef CONFIG_IP_VS_NFCT
0912     int         sysctl_conntrack;
0913 #endif
0914     int         sysctl_snat_reroute;
0915     int         sysctl_sync_ver;
0916     int         sysctl_sync_ports;
0917     int         sysctl_sync_persist_mode;
0918     unsigned long       sysctl_sync_qlen_max;
0919     int         sysctl_sync_sock_size;
0920     int         sysctl_cache_bypass;
0921     int         sysctl_expire_nodest_conn;
0922     int         sysctl_sloppy_tcp;
0923     int         sysctl_sloppy_sctp;
0924     int         sysctl_expire_quiescent_template;
0925     int         sysctl_sync_threshold[2];
0926     unsigned int        sysctl_sync_refresh_period;
0927     int         sysctl_sync_retries;
0928     int         sysctl_nat_icmp_send;
0929     int         sysctl_pmtu_disc;
0930     int         sysctl_backup_only;
0931     int         sysctl_conn_reuse_mode;
0932     int         sysctl_schedule_icmp;
0933     int         sysctl_ignore_tunneled;
0934     int         sysctl_run_estimation;
0935 
0936     /* ip_vs_lblc */
0937     int         sysctl_lblc_expiration;
0938     struct ctl_table_header *lblc_ctl_header;
0939     struct ctl_table    *lblc_ctl_table;
0940     /* ip_vs_lblcr */
0941     int         sysctl_lblcr_expiration;
0942     struct ctl_table_header *lblcr_ctl_header;
0943     struct ctl_table    *lblcr_ctl_table;
0944     /* ip_vs_est */
0945     struct list_head    est_list;   /* estimator list */
0946     spinlock_t      est_lock;
0947     struct timer_list   est_timer;  /* Estimation timer */
0948     /* ip_vs_sync */
0949     spinlock_t      sync_lock;
0950     struct ipvs_master_sync_state *ms;
0951     spinlock_t      sync_buff_lock;
0952     struct ip_vs_sync_thread_data *master_tinfo;
0953     struct ip_vs_sync_thread_data *backup_tinfo;
0954     int         threads_mask;
0955     volatile int        sync_state;
0956     struct mutex        sync_mutex;
0957     struct ipvs_sync_daemon_cfg mcfg;   /* Master Configuration */
0958     struct ipvs_sync_daemon_cfg bcfg;   /* Backup Configuration */
0959     /* net name space ptr */
0960     struct net      *net;            /* Needed by timer routines */
0961     /* Number of heterogeneous destinations, needed becaus heterogeneous
0962      * are not supported when synchronization is enabled.
0963      */
0964     unsigned int        mixed_address_family_dests;
0965     unsigned int        hooks_afmask;   /* &1=AF_INET, &2=AF_INET6 */
0966 };
0967 
0968 #define DEFAULT_SYNC_THRESHOLD  3
0969 #define DEFAULT_SYNC_PERIOD 50
0970 #define DEFAULT_SYNC_VER    1
0971 #define DEFAULT_SLOPPY_TCP  0
0972 #define DEFAULT_SLOPPY_SCTP 0
0973 #define DEFAULT_SYNC_REFRESH_PERIOD (0U * HZ)
0974 #define DEFAULT_SYNC_RETRIES        0
0975 #define IPVS_SYNC_WAKEUP_RATE   8
0976 #define IPVS_SYNC_QLEN_MAX  (IPVS_SYNC_WAKEUP_RATE * 4)
0977 #define IPVS_SYNC_SEND_DELAY    (HZ / 50)
0978 #define IPVS_SYNC_CHECK_PERIOD  HZ
0979 #define IPVS_SYNC_FLUSH_TIME    (HZ * 2)
0980 #define IPVS_SYNC_PORTS_MAX (1 << 6)
0981 
0982 #ifdef CONFIG_SYSCTL
0983 
0984 static inline int sysctl_sync_threshold(struct netns_ipvs *ipvs)
0985 {
0986     return ipvs->sysctl_sync_threshold[0];
0987 }
0988 
0989 static inline int sysctl_sync_period(struct netns_ipvs *ipvs)
0990 {
0991     return READ_ONCE(ipvs->sysctl_sync_threshold[1]);
0992 }
0993 
0994 static inline unsigned int sysctl_sync_refresh_period(struct netns_ipvs *ipvs)
0995 {
0996     return READ_ONCE(ipvs->sysctl_sync_refresh_period);
0997 }
0998 
0999 static inline int sysctl_sync_retries(struct netns_ipvs *ipvs)
1000 {
1001     return ipvs->sysctl_sync_retries;
1002 }
1003 
1004 static inline int sysctl_sync_ver(struct netns_ipvs *ipvs)
1005 {
1006     return ipvs->sysctl_sync_ver;
1007 }
1008 
1009 static inline int sysctl_sloppy_tcp(struct netns_ipvs *ipvs)
1010 {
1011     return ipvs->sysctl_sloppy_tcp;
1012 }
1013 
1014 static inline int sysctl_sloppy_sctp(struct netns_ipvs *ipvs)
1015 {
1016     return ipvs->sysctl_sloppy_sctp;
1017 }
1018 
1019 static inline int sysctl_sync_ports(struct netns_ipvs *ipvs)
1020 {
1021     return READ_ONCE(ipvs->sysctl_sync_ports);
1022 }
1023 
1024 static inline int sysctl_sync_persist_mode(struct netns_ipvs *ipvs)
1025 {
1026     return ipvs->sysctl_sync_persist_mode;
1027 }
1028 
1029 static inline unsigned long sysctl_sync_qlen_max(struct netns_ipvs *ipvs)
1030 {
1031     return ipvs->sysctl_sync_qlen_max;
1032 }
1033 
1034 static inline int sysctl_sync_sock_size(struct netns_ipvs *ipvs)
1035 {
1036     return ipvs->sysctl_sync_sock_size;
1037 }
1038 
1039 static inline int sysctl_pmtu_disc(struct netns_ipvs *ipvs)
1040 {
1041     return ipvs->sysctl_pmtu_disc;
1042 }
1043 
1044 static inline int sysctl_backup_only(struct netns_ipvs *ipvs)
1045 {
1046     return ipvs->sync_state & IP_VS_STATE_BACKUP &&
1047            ipvs->sysctl_backup_only;
1048 }
1049 
1050 static inline int sysctl_conn_reuse_mode(struct netns_ipvs *ipvs)
1051 {
1052     return ipvs->sysctl_conn_reuse_mode;
1053 }
1054 
1055 static inline int sysctl_expire_nodest_conn(struct netns_ipvs *ipvs)
1056 {
1057     return ipvs->sysctl_expire_nodest_conn;
1058 }
1059 
1060 static inline int sysctl_schedule_icmp(struct netns_ipvs *ipvs)
1061 {
1062     return ipvs->sysctl_schedule_icmp;
1063 }
1064 
1065 static inline int sysctl_ignore_tunneled(struct netns_ipvs *ipvs)
1066 {
1067     return ipvs->sysctl_ignore_tunneled;
1068 }
1069 
1070 static inline int sysctl_cache_bypass(struct netns_ipvs *ipvs)
1071 {
1072     return ipvs->sysctl_cache_bypass;
1073 }
1074 
1075 static inline int sysctl_run_estimation(struct netns_ipvs *ipvs)
1076 {
1077     return ipvs->sysctl_run_estimation;
1078 }
1079 
1080 #else
1081 
1082 static inline int sysctl_sync_threshold(struct netns_ipvs *ipvs)
1083 {
1084     return DEFAULT_SYNC_THRESHOLD;
1085 }
1086 
1087 static inline int sysctl_sync_period(struct netns_ipvs *ipvs)
1088 {
1089     return DEFAULT_SYNC_PERIOD;
1090 }
1091 
1092 static inline unsigned int sysctl_sync_refresh_period(struct netns_ipvs *ipvs)
1093 {
1094     return DEFAULT_SYNC_REFRESH_PERIOD;
1095 }
1096 
1097 static inline int sysctl_sync_retries(struct netns_ipvs *ipvs)
1098 {
1099     return DEFAULT_SYNC_RETRIES & 3;
1100 }
1101 
1102 static inline int sysctl_sync_ver(struct netns_ipvs *ipvs)
1103 {
1104     return DEFAULT_SYNC_VER;
1105 }
1106 
1107 static inline int sysctl_sloppy_tcp(struct netns_ipvs *ipvs)
1108 {
1109     return DEFAULT_SLOPPY_TCP;
1110 }
1111 
1112 static inline int sysctl_sloppy_sctp(struct netns_ipvs *ipvs)
1113 {
1114     return DEFAULT_SLOPPY_SCTP;
1115 }
1116 
1117 static inline int sysctl_sync_ports(struct netns_ipvs *ipvs)
1118 {
1119     return 1;
1120 }
1121 
1122 static inline int sysctl_sync_persist_mode(struct netns_ipvs *ipvs)
1123 {
1124     return 0;
1125 }
1126 
1127 static inline unsigned long sysctl_sync_qlen_max(struct netns_ipvs *ipvs)
1128 {
1129     return IPVS_SYNC_QLEN_MAX;
1130 }
1131 
1132 static inline int sysctl_sync_sock_size(struct netns_ipvs *ipvs)
1133 {
1134     return 0;
1135 }
1136 
1137 static inline int sysctl_pmtu_disc(struct netns_ipvs *ipvs)
1138 {
1139     return 1;
1140 }
1141 
1142 static inline int sysctl_backup_only(struct netns_ipvs *ipvs)
1143 {
1144     return 0;
1145 }
1146 
1147 static inline int sysctl_conn_reuse_mode(struct netns_ipvs *ipvs)
1148 {
1149     return 1;
1150 }
1151 
1152 static inline int sysctl_expire_nodest_conn(struct netns_ipvs *ipvs)
1153 {
1154     return 0;
1155 }
1156 
1157 static inline int sysctl_schedule_icmp(struct netns_ipvs *ipvs)
1158 {
1159     return 0;
1160 }
1161 
1162 static inline int sysctl_ignore_tunneled(struct netns_ipvs *ipvs)
1163 {
1164     return 0;
1165 }
1166 
1167 static inline int sysctl_cache_bypass(struct netns_ipvs *ipvs)
1168 {
1169     return 0;
1170 }
1171 
1172 static inline int sysctl_run_estimation(struct netns_ipvs *ipvs)
1173 {
1174     return 1;
1175 }
1176 
1177 #endif
1178 
1179 /* IPVS core functions
1180  * (from ip_vs_core.c)
1181  */
1182 const char *ip_vs_proto_name(unsigned int proto);
1183 void ip_vs_init_hash_table(struct list_head *table, int rows);
1184 struct ip_vs_conn *ip_vs_new_conn_out(struct ip_vs_service *svc,
1185                       struct ip_vs_dest *dest,
1186                       struct sk_buff *skb,
1187                       const struct ip_vs_iphdr *iph,
1188                       __be16 dport,
1189                       __be16 cport);
1190 #define IP_VS_INIT_HASH_TABLE(t) ip_vs_init_hash_table((t), ARRAY_SIZE((t)))
1191 
1192 #define IP_VS_APP_TYPE_FTP  1
1193 
1194 /* ip_vs_conn handling functions
1195  * (from ip_vs_conn.c)
1196  */
1197 enum {
1198     IP_VS_DIR_INPUT = 0,
1199     IP_VS_DIR_OUTPUT,
1200     IP_VS_DIR_INPUT_ONLY,
1201     IP_VS_DIR_LAST,
1202 };
1203 
1204 static inline void ip_vs_conn_fill_param(struct netns_ipvs *ipvs, int af, int protocol,
1205                      const union nf_inet_addr *caddr,
1206                      __be16 cport,
1207                      const union nf_inet_addr *vaddr,
1208                      __be16 vport,
1209                      struct ip_vs_conn_param *p)
1210 {
1211     p->ipvs = ipvs;
1212     p->af = af;
1213     p->protocol = protocol;
1214     p->caddr = caddr;
1215     p->cport = cport;
1216     p->vaddr = vaddr;
1217     p->vport = vport;
1218     p->pe = NULL;
1219     p->pe_data = NULL;
1220 }
1221 
1222 struct ip_vs_conn *ip_vs_conn_in_get(const struct ip_vs_conn_param *p);
1223 struct ip_vs_conn *ip_vs_ct_in_get(const struct ip_vs_conn_param *p);
1224 
1225 struct ip_vs_conn * ip_vs_conn_in_get_proto(struct netns_ipvs *ipvs, int af,
1226                         const struct sk_buff *skb,
1227                         const struct ip_vs_iphdr *iph);
1228 
1229 struct ip_vs_conn *ip_vs_conn_out_get(const struct ip_vs_conn_param *p);
1230 
1231 struct ip_vs_conn * ip_vs_conn_out_get_proto(struct netns_ipvs *ipvs, int af,
1232                          const struct sk_buff *skb,
1233                          const struct ip_vs_iphdr *iph);
1234 
1235 /* Get reference to gain full access to conn.
1236  * By default, RCU read-side critical sections have access only to
1237  * conn fields and its PE data, see ip_vs_conn_rcu_free() for reference.
1238  */
1239 static inline bool __ip_vs_conn_get(struct ip_vs_conn *cp)
1240 {
1241     return refcount_inc_not_zero(&cp->refcnt);
1242 }
1243 
1244 /* put back the conn without restarting its timer */
1245 static inline void __ip_vs_conn_put(struct ip_vs_conn *cp)
1246 {
1247     smp_mb__before_atomic();
1248     refcount_dec(&cp->refcnt);
1249 }
1250 void ip_vs_conn_put(struct ip_vs_conn *cp);
1251 void ip_vs_conn_fill_cport(struct ip_vs_conn *cp, __be16 cport);
1252 
1253 struct ip_vs_conn *ip_vs_conn_new(const struct ip_vs_conn_param *p, int dest_af,
1254                   const union nf_inet_addr *daddr,
1255                   __be16 dport, unsigned int flags,
1256                   struct ip_vs_dest *dest, __u32 fwmark);
1257 void ip_vs_conn_expire_now(struct ip_vs_conn *cp);
1258 
1259 const char *ip_vs_state_name(const struct ip_vs_conn *cp);
1260 
1261 void ip_vs_tcp_conn_listen(struct ip_vs_conn *cp);
1262 int ip_vs_check_template(struct ip_vs_conn *ct, struct ip_vs_dest *cdest);
1263 void ip_vs_random_dropentry(struct netns_ipvs *ipvs);
1264 int ip_vs_conn_init(void);
1265 void ip_vs_conn_cleanup(void);
1266 
1267 static inline void ip_vs_control_del(struct ip_vs_conn *cp)
1268 {
1269     struct ip_vs_conn *ctl_cp = cp->control;
1270     if (!ctl_cp) {
1271         IP_VS_ERR_BUF("request control DEL for uncontrolled: "
1272                   "%s:%d to %s:%d\n",
1273                   IP_VS_DBG_ADDR(cp->af, &cp->caddr),
1274                   ntohs(cp->cport),
1275                   IP_VS_DBG_ADDR(cp->af, &cp->vaddr),
1276                   ntohs(cp->vport));
1277 
1278         return;
1279     }
1280 
1281     IP_VS_DBG_BUF(7, "DELeting control for: "
1282               "cp.dst=%s:%d ctl_cp.dst=%s:%d\n",
1283               IP_VS_DBG_ADDR(cp->af, &cp->caddr),
1284               ntohs(cp->cport),
1285               IP_VS_DBG_ADDR(cp->af, &ctl_cp->caddr),
1286               ntohs(ctl_cp->cport));
1287 
1288     cp->control = NULL;
1289     if (atomic_read(&ctl_cp->n_control) == 0) {
1290         IP_VS_ERR_BUF("BUG control DEL with n=0 : "
1291                   "%s:%d to %s:%d\n",
1292                   IP_VS_DBG_ADDR(cp->af, &cp->caddr),
1293                   ntohs(cp->cport),
1294                   IP_VS_DBG_ADDR(cp->af, &cp->vaddr),
1295                   ntohs(cp->vport));
1296 
1297         return;
1298     }
1299     atomic_dec(&ctl_cp->n_control);
1300 }
1301 
1302 static inline void
1303 ip_vs_control_add(struct ip_vs_conn *cp, struct ip_vs_conn *ctl_cp)
1304 {
1305     if (cp->control) {
1306         IP_VS_ERR_BUF("request control ADD for already controlled: "
1307                   "%s:%d to %s:%d\n",
1308                   IP_VS_DBG_ADDR(cp->af, &cp->caddr),
1309                   ntohs(cp->cport),
1310                   IP_VS_DBG_ADDR(cp->af, &cp->vaddr),
1311                   ntohs(cp->vport));
1312 
1313         ip_vs_control_del(cp);
1314     }
1315 
1316     IP_VS_DBG_BUF(7, "ADDing control for: "
1317               "cp.dst=%s:%d ctl_cp.dst=%s:%d\n",
1318               IP_VS_DBG_ADDR(cp->af, &cp->caddr),
1319               ntohs(cp->cport),
1320               IP_VS_DBG_ADDR(cp->af, &ctl_cp->caddr),
1321               ntohs(ctl_cp->cport));
1322 
1323     cp->control = ctl_cp;
1324     atomic_inc(&ctl_cp->n_control);
1325 }
1326 
1327 /* Mark our template as assured */
1328 static inline void
1329 ip_vs_control_assure_ct(struct ip_vs_conn *cp)
1330 {
1331     struct ip_vs_conn *ct = cp->control;
1332 
1333     if (ct && !(ct->state & IP_VS_CTPL_S_ASSURED) &&
1334         (ct->flags & IP_VS_CONN_F_TEMPLATE))
1335         ct->state |= IP_VS_CTPL_S_ASSURED;
1336 }
1337 
1338 /* IPVS netns init & cleanup functions */
1339 int ip_vs_estimator_net_init(struct netns_ipvs *ipvs);
1340 int ip_vs_control_net_init(struct netns_ipvs *ipvs);
1341 int ip_vs_protocol_net_init(struct netns_ipvs *ipvs);
1342 int ip_vs_app_net_init(struct netns_ipvs *ipvs);
1343 int ip_vs_conn_net_init(struct netns_ipvs *ipvs);
1344 int ip_vs_sync_net_init(struct netns_ipvs *ipvs);
1345 void ip_vs_conn_net_cleanup(struct netns_ipvs *ipvs);
1346 void ip_vs_app_net_cleanup(struct netns_ipvs *ipvs);
1347 void ip_vs_protocol_net_cleanup(struct netns_ipvs *ipvs);
1348 void ip_vs_control_net_cleanup(struct netns_ipvs *ipvs);
1349 void ip_vs_estimator_net_cleanup(struct netns_ipvs *ipvs);
1350 void ip_vs_sync_net_cleanup(struct netns_ipvs *ipvs);
1351 void ip_vs_service_nets_cleanup(struct list_head *net_list);
1352 
1353 /* IPVS application functions
1354  * (from ip_vs_app.c)
1355  */
1356 #define IP_VS_APP_MAX_PORTS  8
1357 struct ip_vs_app *register_ip_vs_app(struct netns_ipvs *ipvs, struct ip_vs_app *app);
1358 void unregister_ip_vs_app(struct netns_ipvs *ipvs, struct ip_vs_app *app);
1359 int ip_vs_bind_app(struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
1360 void ip_vs_unbind_app(struct ip_vs_conn *cp);
1361 int register_ip_vs_app_inc(struct netns_ipvs *ipvs, struct ip_vs_app *app, __u16 proto,
1362                __u16 port);
1363 int ip_vs_app_inc_get(struct ip_vs_app *inc);
1364 void ip_vs_app_inc_put(struct ip_vs_app *inc);
1365 
1366 int ip_vs_app_pkt_out(struct ip_vs_conn *, struct sk_buff *skb,
1367               struct ip_vs_iphdr *ipvsh);
1368 int ip_vs_app_pkt_in(struct ip_vs_conn *, struct sk_buff *skb,
1369              struct ip_vs_iphdr *ipvsh);
1370 
1371 int register_ip_vs_pe(struct ip_vs_pe *pe);
1372 int unregister_ip_vs_pe(struct ip_vs_pe *pe);
1373 struct ip_vs_pe *ip_vs_pe_getbyname(const char *name);
1374 struct ip_vs_pe *__ip_vs_pe_getbyname(const char *pe_name);
1375 
1376 /* Use a #define to avoid all of module.h just for these trivial ops */
1377 #define ip_vs_pe_get(pe)            \
1378     if (pe && pe->module)           \
1379         __module_get(pe->module);
1380 
1381 #define ip_vs_pe_put(pe)            \
1382     if (pe && pe->module)           \
1383         module_put(pe->module);
1384 
1385 /* IPVS protocol functions (from ip_vs_proto.c) */
1386 int ip_vs_protocol_init(void);
1387 void ip_vs_protocol_cleanup(void);
1388 void ip_vs_protocol_timeout_change(struct netns_ipvs *ipvs, int flags);
1389 int *ip_vs_create_timeout_table(int *table, int size);
1390 void ip_vs_tcpudp_debug_packet(int af, struct ip_vs_protocol *pp,
1391                    const struct sk_buff *skb, int offset,
1392                    const char *msg);
1393 
1394 extern struct ip_vs_protocol ip_vs_protocol_tcp;
1395 extern struct ip_vs_protocol ip_vs_protocol_udp;
1396 extern struct ip_vs_protocol ip_vs_protocol_icmp;
1397 extern struct ip_vs_protocol ip_vs_protocol_esp;
1398 extern struct ip_vs_protocol ip_vs_protocol_ah;
1399 extern struct ip_vs_protocol ip_vs_protocol_sctp;
1400 
1401 /* Registering/unregistering scheduler functions
1402  * (from ip_vs_sched.c)
1403  */
1404 int register_ip_vs_scheduler(struct ip_vs_scheduler *scheduler);
1405 int unregister_ip_vs_scheduler(struct ip_vs_scheduler *scheduler);
1406 int ip_vs_bind_scheduler(struct ip_vs_service *svc,
1407              struct ip_vs_scheduler *scheduler);
1408 void ip_vs_unbind_scheduler(struct ip_vs_service *svc,
1409                 struct ip_vs_scheduler *sched);
1410 struct ip_vs_scheduler *ip_vs_scheduler_get(const char *sched_name);
1411 void ip_vs_scheduler_put(struct ip_vs_scheduler *scheduler);
1412 struct ip_vs_conn *
1413 ip_vs_schedule(struct ip_vs_service *svc, struct sk_buff *skb,
1414            struct ip_vs_proto_data *pd, int *ignored,
1415            struct ip_vs_iphdr *iph);
1416 int ip_vs_leave(struct ip_vs_service *svc, struct sk_buff *skb,
1417         struct ip_vs_proto_data *pd, struct ip_vs_iphdr *iph);
1418 
1419 void ip_vs_scheduler_err(struct ip_vs_service *svc, const char *msg);
1420 
1421 /* IPVS control data and functions (from ip_vs_ctl.c) */
1422 extern struct ip_vs_stats ip_vs_stats;
1423 extern int sysctl_ip_vs_sync_ver;
1424 
1425 struct ip_vs_service *
1426 ip_vs_service_find(struct netns_ipvs *ipvs, int af, __u32 fwmark, __u16 protocol,
1427           const union nf_inet_addr *vaddr, __be16 vport);
1428 
1429 bool ip_vs_has_real_service(struct netns_ipvs *ipvs, int af, __u16 protocol,
1430                 const union nf_inet_addr *daddr, __be16 dport);
1431 
1432 struct ip_vs_dest *
1433 ip_vs_find_real_service(struct netns_ipvs *ipvs, int af, __u16 protocol,
1434             const union nf_inet_addr *daddr, __be16 dport);
1435 struct ip_vs_dest *ip_vs_find_tunnel(struct netns_ipvs *ipvs, int af,
1436                      const union nf_inet_addr *daddr,
1437                      __be16 tun_port);
1438 
1439 int ip_vs_use_count_inc(void);
1440 void ip_vs_use_count_dec(void);
1441 int ip_vs_register_nl_ioctl(void);
1442 void ip_vs_unregister_nl_ioctl(void);
1443 int ip_vs_control_init(void);
1444 void ip_vs_control_cleanup(void);
1445 struct ip_vs_dest *
1446 ip_vs_find_dest(struct netns_ipvs *ipvs, int svc_af, int dest_af,
1447         const union nf_inet_addr *daddr, __be16 dport,
1448         const union nf_inet_addr *vaddr, __be16 vport,
1449         __u16 protocol, __u32 fwmark, __u32 flags);
1450 void ip_vs_try_bind_dest(struct ip_vs_conn *cp);
1451 
1452 static inline void ip_vs_dest_hold(struct ip_vs_dest *dest)
1453 {
1454     refcount_inc(&dest->refcnt);
1455 }
1456 
1457 static inline void ip_vs_dest_put(struct ip_vs_dest *dest)
1458 {
1459     smp_mb__before_atomic();
1460     refcount_dec(&dest->refcnt);
1461 }
1462 
1463 static inline void ip_vs_dest_put_and_free(struct ip_vs_dest *dest)
1464 {
1465     if (refcount_dec_and_test(&dest->refcnt))
1466         kfree(dest);
1467 }
1468 
1469 /* IPVS sync daemon data and function prototypes
1470  * (from ip_vs_sync.c)
1471  */
1472 int start_sync_thread(struct netns_ipvs *ipvs, struct ipvs_sync_daemon_cfg *cfg,
1473               int state);
1474 int stop_sync_thread(struct netns_ipvs *ipvs, int state);
1475 void ip_vs_sync_conn(struct netns_ipvs *ipvs, struct ip_vs_conn *cp, int pkts);
1476 
1477 /* IPVS rate estimator prototypes (from ip_vs_est.c) */
1478 void ip_vs_start_estimator(struct netns_ipvs *ipvs, struct ip_vs_stats *stats);
1479 void ip_vs_stop_estimator(struct netns_ipvs *ipvs, struct ip_vs_stats *stats);
1480 void ip_vs_zero_estimator(struct ip_vs_stats *stats);
1481 void ip_vs_read_estimator(struct ip_vs_kstats *dst, struct ip_vs_stats *stats);
1482 
1483 /* Various IPVS packet transmitters (from ip_vs_xmit.c) */
1484 int ip_vs_null_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
1485             struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1486 int ip_vs_bypass_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
1487               struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1488 int ip_vs_nat_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
1489            struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1490 int ip_vs_tunnel_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
1491               struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1492 int ip_vs_dr_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
1493           struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1494 int ip_vs_icmp_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
1495             struct ip_vs_protocol *pp, int offset,
1496             unsigned int hooknum, struct ip_vs_iphdr *iph);
1497 void ip_vs_dest_dst_rcu_free(struct rcu_head *head);
1498 
1499 #ifdef CONFIG_IP_VS_IPV6
1500 int ip_vs_bypass_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp,
1501              struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1502 int ip_vs_nat_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp,
1503               struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1504 int ip_vs_tunnel_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp,
1505              struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1506 int ip_vs_dr_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp,
1507              struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1508 int ip_vs_icmp_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp,
1509                struct ip_vs_protocol *pp, int offset,
1510                unsigned int hooknum, struct ip_vs_iphdr *iph);
1511 #endif
1512 
1513 #ifdef CONFIG_SYSCTL
1514 /* This is a simple mechanism to ignore packets when
1515  * we are loaded. Just set ip_vs_drop_rate to 'n' and
1516  * we start to drop 1/rate of the packets
1517  */
1518 static inline int ip_vs_todrop(struct netns_ipvs *ipvs)
1519 {
1520     if (!ipvs->drop_rate)
1521         return 0;
1522     if (--ipvs->drop_counter > 0)
1523         return 0;
1524     ipvs->drop_counter = ipvs->drop_rate;
1525     return 1;
1526 }
1527 #else
1528 static inline int ip_vs_todrop(struct netns_ipvs *ipvs) { return 0; }
1529 #endif
1530 
1531 #ifdef CONFIG_SYSCTL
1532 /* Enqueue delayed work for expiring no dest connections
1533  * Only run when sysctl_expire_nodest=1
1534  */
1535 static inline void ip_vs_enqueue_expire_nodest_conns(struct netns_ipvs *ipvs)
1536 {
1537     if (sysctl_expire_nodest_conn(ipvs))
1538         queue_delayed_work(system_long_wq,
1539                    &ipvs->expire_nodest_conn_work, 1);
1540 }
1541 
1542 void ip_vs_expire_nodest_conn_flush(struct netns_ipvs *ipvs);
1543 #else
1544 static inline void ip_vs_enqueue_expire_nodest_conns(struct netns_ipvs *ipvs) {}
1545 #endif
1546 
1547 #define IP_VS_DFWD_METHOD(dest) (atomic_read(&(dest)->conn_flags) & \
1548                  IP_VS_CONN_F_FWD_MASK)
1549 
1550 /* ip_vs_fwd_tag returns the forwarding tag of the connection */
1551 #define IP_VS_FWD_METHOD(cp)  (cp->flags & IP_VS_CONN_F_FWD_MASK)
1552 
1553 static inline char ip_vs_fwd_tag(struct ip_vs_conn *cp)
1554 {
1555     char fwd;
1556 
1557     switch (IP_VS_FWD_METHOD(cp)) {
1558     case IP_VS_CONN_F_MASQ:
1559         fwd = 'M'; break;
1560     case IP_VS_CONN_F_LOCALNODE:
1561         fwd = 'L'; break;
1562     case IP_VS_CONN_F_TUNNEL:
1563         fwd = 'T'; break;
1564     case IP_VS_CONN_F_DROUTE:
1565         fwd = 'R'; break;
1566     case IP_VS_CONN_F_BYPASS:
1567         fwd = 'B'; break;
1568     default:
1569         fwd = '?'; break;
1570     }
1571     return fwd;
1572 }
1573 
1574 void ip_vs_nat_icmp(struct sk_buff *skb, struct ip_vs_protocol *pp,
1575             struct ip_vs_conn *cp, int dir);
1576 
1577 #ifdef CONFIG_IP_VS_IPV6
1578 void ip_vs_nat_icmp_v6(struct sk_buff *skb, struct ip_vs_protocol *pp,
1579                struct ip_vs_conn *cp, int dir);
1580 #endif
1581 
1582 __sum16 ip_vs_checksum_complete(struct sk_buff *skb, int offset);
1583 
1584 static inline __wsum ip_vs_check_diff4(__be32 old, __be32 new, __wsum oldsum)
1585 {
1586     __be32 diff[2] = { ~old, new };
1587 
1588     return csum_partial(diff, sizeof(diff), oldsum);
1589 }
1590 
1591 #ifdef CONFIG_IP_VS_IPV6
1592 static inline __wsum ip_vs_check_diff16(const __be32 *old, const __be32 *new,
1593                     __wsum oldsum)
1594 {
1595     __be32 diff[8] = { ~old[3], ~old[2], ~old[1], ~old[0],
1596                 new[3],  new[2],  new[1],  new[0] };
1597 
1598     return csum_partial(diff, sizeof(diff), oldsum);
1599 }
1600 #endif
1601 
1602 static inline __wsum ip_vs_check_diff2(__be16 old, __be16 new, __wsum oldsum)
1603 {
1604     __be16 diff[2] = { ~old, new };
1605 
1606     return csum_partial(diff, sizeof(diff), oldsum);
1607 }
1608 
1609 /* Forget current conntrack (unconfirmed) and attach notrack entry */
1610 static inline void ip_vs_notrack(struct sk_buff *skb)
1611 {
1612 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
1613     enum ip_conntrack_info ctinfo;
1614     struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1615 
1616     if (ct) {
1617         nf_conntrack_put(&ct->ct_general);
1618         nf_ct_set(skb, NULL, IP_CT_UNTRACKED);
1619     }
1620 #endif
1621 }
1622 
1623 #ifdef CONFIG_IP_VS_NFCT
1624 /* Netfilter connection tracking
1625  * (from ip_vs_nfct.c)
1626  */
1627 static inline int ip_vs_conntrack_enabled(struct netns_ipvs *ipvs)
1628 {
1629 #ifdef CONFIG_SYSCTL
1630     return ipvs->sysctl_conntrack;
1631 #else
1632     return 0;
1633 #endif
1634 }
1635 
1636 void ip_vs_update_conntrack(struct sk_buff *skb, struct ip_vs_conn *cp,
1637                 int outin);
1638 int ip_vs_confirm_conntrack(struct sk_buff *skb);
1639 void ip_vs_nfct_expect_related(struct sk_buff *skb, struct nf_conn *ct,
1640                    struct ip_vs_conn *cp, u_int8_t proto,
1641                    const __be16 port, int from_rs);
1642 void ip_vs_conn_drop_conntrack(struct ip_vs_conn *cp);
1643 
1644 #else
1645 
1646 static inline int ip_vs_conntrack_enabled(struct netns_ipvs *ipvs)
1647 {
1648     return 0;
1649 }
1650 
1651 static inline void ip_vs_update_conntrack(struct sk_buff *skb,
1652                       struct ip_vs_conn *cp, int outin)
1653 {
1654 }
1655 
1656 static inline int ip_vs_confirm_conntrack(struct sk_buff *skb)
1657 {
1658     return NF_ACCEPT;
1659 }
1660 
1661 static inline void ip_vs_conn_drop_conntrack(struct ip_vs_conn *cp)
1662 {
1663 }
1664 #endif /* CONFIG_IP_VS_NFCT */
1665 
1666 /* Using old conntrack that can not be redirected to another real server? */
1667 static inline bool ip_vs_conn_uses_old_conntrack(struct ip_vs_conn *cp,
1668                          struct sk_buff *skb)
1669 {
1670 #ifdef CONFIG_IP_VS_NFCT
1671     enum ip_conntrack_info ctinfo;
1672     struct nf_conn *ct;
1673 
1674     ct = nf_ct_get(skb, &ctinfo);
1675     if (ct && nf_ct_is_confirmed(ct))
1676         return true;
1677 #endif
1678     return false;
1679 }
1680 
1681 static inline int ip_vs_register_conntrack(struct ip_vs_service *svc)
1682 {
1683 #if IS_ENABLED(CONFIG_NF_CONNTRACK)
1684     int afmask = (svc->af == AF_INET6) ? 2 : 1;
1685     int ret = 0;
1686 
1687     if (!(svc->conntrack_afmask & afmask)) {
1688         ret = nf_ct_netns_get(svc->ipvs->net, svc->af);
1689         if (ret >= 0)
1690             svc->conntrack_afmask |= afmask;
1691     }
1692     return ret;
1693 #else
1694     return 0;
1695 #endif
1696 }
1697 
1698 static inline void ip_vs_unregister_conntrack(struct ip_vs_service *svc)
1699 {
1700 #if IS_ENABLED(CONFIG_NF_CONNTRACK)
1701     int afmask = (svc->af == AF_INET6) ? 2 : 1;
1702 
1703     if (svc->conntrack_afmask & afmask) {
1704         nf_ct_netns_put(svc->ipvs->net, svc->af);
1705         svc->conntrack_afmask &= ~afmask;
1706     }
1707 #endif
1708 }
1709 
1710 int ip_vs_register_hooks(struct netns_ipvs *ipvs, unsigned int af);
1711 void ip_vs_unregister_hooks(struct netns_ipvs *ipvs, unsigned int af);
1712 
1713 static inline int
1714 ip_vs_dest_conn_overhead(struct ip_vs_dest *dest)
1715 {
1716     /* We think the overhead of processing active connections is 256
1717      * times higher than that of inactive connections in average. (This
1718      * 256 times might not be accurate, we will change it later) We
1719      * use the following formula to estimate the overhead now:
1720      *        dest->activeconns*256 + dest->inactconns
1721      */
1722     return (atomic_read(&dest->activeconns) << 8) +
1723         atomic_read(&dest->inactconns);
1724 }
1725 
1726 #ifdef CONFIG_IP_VS_PROTO_TCP
1727 INDIRECT_CALLABLE_DECLARE(int
1728     tcp_snat_handler(struct sk_buff *skb, struct ip_vs_protocol *pp,
1729              struct ip_vs_conn *cp, struct ip_vs_iphdr *iph));
1730 #endif
1731 
1732 #ifdef CONFIG_IP_VS_PROTO_UDP
1733 INDIRECT_CALLABLE_DECLARE(int
1734     udp_snat_handler(struct sk_buff *skb, struct ip_vs_protocol *pp,
1735              struct ip_vs_conn *cp, struct ip_vs_iphdr *iph));
1736 #endif
1737 #endif  /* _NET_IP_VS_H */
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!