~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/net/ip_vs.h

Version: ~ [ linux-5.14-rc1 ] ~ [ linux-5.13.1 ] ~ [ linux-5.12.16 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.49 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.131 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.197 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.239 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.275 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.275 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* SPDX-License-Identifier: GPL-2.0 */
  2 /* IP Virtual Server
  3  * data structure and functionality definitions
  4  */
  5 
  6 #ifndef _NET_IP_VS_H
  7 #define _NET_IP_VS_H
  8 
  9 #include <linux/ip_vs.h>                /* definitions shared with userland */
 10 
 11 #include <asm/types.h>                  /* for __uXX types */
 12 
 13 #include <linux/list.h>                 /* for struct list_head */
 14 #include <linux/spinlock.h>             /* for struct rwlock_t */
 15 #include <linux/atomic.h>               /* for struct atomic_t */
 16 #include <linux/refcount.h>             /* for struct refcount_t */
 17 
 18 #include <linux/compiler.h>
 19 #include <linux/timer.h>
 20 #include <linux/bug.h>
 21 
 22 #include <net/checksum.h>
 23 #include <linux/netfilter.h>            /* for union nf_inet_addr */
 24 #include <linux/ip.h>
 25 #include <linux/ipv6.h>                 /* for struct ipv6hdr */
 26 #include <net/ipv6.h>
 27 #if IS_ENABLED(CONFIG_IP_VS_IPV6)
 28 #include <linux/netfilter_ipv6/ip6_tables.h>
 29 #endif
 30 #if IS_ENABLED(CONFIG_NF_CONNTRACK)
 31 #include <net/netfilter/nf_conntrack.h>
 32 #endif
 33 #include <net/net_namespace.h>          /* Netw namespace */
 34 
 35 #define IP_VS_HDR_INVERSE       1
 36 #define IP_VS_HDR_ICMP          2
 37 
 38 /* Generic access of ipvs struct */
 39 static inline struct netns_ipvs *net_ipvs(struct net* net)
 40 {
 41         return net->ipvs;
 42 }
 43 
 44 /* Connections' size value needed by ip_vs_ctl.c */
 45 extern int ip_vs_conn_tab_size;
 46 
 47 struct ip_vs_iphdr {
 48         int hdr_flags;  /* ipvs flags */
 49         __u32 off;      /* Where IP or IPv4 header starts */
 50         __u32 len;      /* IPv4 simply where L4 starts
 51                          * IPv6 where L4 Transport Header starts */
 52         __u16 fragoffs; /* IPv6 fragment offset, 0 if first frag (or not frag)*/
 53         __s16 protocol;
 54         __s32 flags;
 55         union nf_inet_addr saddr;
 56         union nf_inet_addr daddr;
 57 };
 58 
 59 static inline void *frag_safe_skb_hp(const struct sk_buff *skb, int offset,
 60                                       int len, void *buffer)
 61 {
 62         return skb_header_pointer(skb, offset, len, buffer);
 63 }
 64 
 65 /* This function handles filling *ip_vs_iphdr, both for IPv4 and IPv6.
 66  * IPv6 requires some extra work, as finding proper header position,
 67  * depend on the IPv6 extension headers.
 68  */
 69 static inline int
 70 ip_vs_fill_iph_skb_off(int af, const struct sk_buff *skb, int offset,
 71                        int hdr_flags, struct ip_vs_iphdr *iphdr)
 72 {
 73         iphdr->hdr_flags = hdr_flags;
 74         iphdr->off = offset;
 75 
 76 #ifdef CONFIG_IP_VS_IPV6
 77         if (af == AF_INET6) {
 78                 struct ipv6hdr _iph;
 79                 const struct ipv6hdr *iph = skb_header_pointer(
 80                         skb, offset, sizeof(_iph), &_iph);
 81                 if (!iph)
 82                         return 0;
 83 
 84                 iphdr->saddr.in6 = iph->saddr;
 85                 iphdr->daddr.in6 = iph->daddr;
 86                 /* ipv6_find_hdr() updates len, flags */
 87                 iphdr->len       = offset;
 88                 iphdr->flags     = 0;
 89                 iphdr->protocol  = ipv6_find_hdr(skb, &iphdr->len, -1,
 90                                                  &iphdr->fragoffs,
 91                                                  &iphdr->flags);
 92                 if (iphdr->protocol < 0)
 93                         return 0;
 94         } else
 95 #endif
 96         {
 97                 struct iphdr _iph;
 98                 const struct iphdr *iph = skb_header_pointer(
 99                         skb, offset, sizeof(_iph), &_iph);
100                 if (!iph)
101                         return 0;
102 
103                 iphdr->len      = offset + iph->ihl * 4;
104                 iphdr->fragoffs = 0;
105                 iphdr->protocol = iph->protocol;
106                 iphdr->saddr.ip = iph->saddr;
107                 iphdr->daddr.ip = iph->daddr;
108         }
109 
110         return 1;
111 }
112 
113 static inline int
114 ip_vs_fill_iph_skb_icmp(int af, const struct sk_buff *skb, int offset,
115                         bool inverse, struct ip_vs_iphdr *iphdr)
116 {
117         int hdr_flags = IP_VS_HDR_ICMP;
118 
119         if (inverse)
120                 hdr_flags |= IP_VS_HDR_INVERSE;
121 
122         return ip_vs_fill_iph_skb_off(af, skb, offset, hdr_flags, iphdr);
123 }
124 
125 static inline int
126 ip_vs_fill_iph_skb(int af, const struct sk_buff *skb, bool inverse,
127                    struct ip_vs_iphdr *iphdr)
128 {
129         int hdr_flags = 0;
130 
131         if (inverse)
132                 hdr_flags |= IP_VS_HDR_INVERSE;
133 
134         return ip_vs_fill_iph_skb_off(af, skb, skb_network_offset(skb),
135                                       hdr_flags, iphdr);
136 }
137 
138 static inline bool
139 ip_vs_iph_inverse(const struct ip_vs_iphdr *iph)
140 {
141         return !!(iph->hdr_flags & IP_VS_HDR_INVERSE);
142 }
143 
144 static inline bool
145 ip_vs_iph_icmp(const struct ip_vs_iphdr *iph)
146 {
147         return !!(iph->hdr_flags & IP_VS_HDR_ICMP);
148 }
149 
150 static inline void ip_vs_addr_copy(int af, union nf_inet_addr *dst,
151                                    const union nf_inet_addr *src)
152 {
153 #ifdef CONFIG_IP_VS_IPV6
154         if (af == AF_INET6)
155                 dst->in6 = src->in6;
156         else
157 #endif
158         dst->ip = src->ip;
159 }
160 
161 static inline void ip_vs_addr_set(int af, union nf_inet_addr *dst,
162                                   const union nf_inet_addr *src)
163 {
164 #ifdef CONFIG_IP_VS_IPV6
165         if (af == AF_INET6) {
166                 dst->in6 = src->in6;
167                 return;
168         }
169 #endif
170         dst->ip = src->ip;
171         dst->all[1] = 0;
172         dst->all[2] = 0;
173         dst->all[3] = 0;
174 }
175 
176 static inline int ip_vs_addr_equal(int af, const union nf_inet_addr *a,
177                                    const union nf_inet_addr *b)
178 {
179 #ifdef CONFIG_IP_VS_IPV6
180         if (af == AF_INET6)
181                 return ipv6_addr_equal(&a->in6, &b->in6);
182 #endif
183         return a->ip == b->ip;
184 }
185 
186 #ifdef CONFIG_IP_VS_DEBUG
187 #include <linux/net.h>
188 
189 int ip_vs_get_debug_level(void);
190 
191 static inline const char *ip_vs_dbg_addr(int af, char *buf, size_t buf_len,
192                                          const union nf_inet_addr *addr,
193                                          int *idx)
194 {
195         int len;
196 #ifdef CONFIG_IP_VS_IPV6
197         if (af == AF_INET6)
198                 len = snprintf(&buf[*idx], buf_len - *idx, "[%pI6c]",
199                                &addr->in6) + 1;
200         else
201 #endif
202                 len = snprintf(&buf[*idx], buf_len - *idx, "%pI4",
203                                &addr->ip) + 1;
204 
205         *idx += len;
206         BUG_ON(*idx > buf_len + 1);
207         return &buf[*idx - len];
208 }
209 
210 #define IP_VS_DBG_BUF(level, msg, ...)                                  \
211         do {                                                            \
212                 char ip_vs_dbg_buf[160];                                \
213                 int ip_vs_dbg_idx = 0;                                  \
214                 if (level <= ip_vs_get_debug_level())                   \
215                         printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__);  \
216         } while (0)
217 #define IP_VS_ERR_BUF(msg...)                                           \
218         do {                                                            \
219                 char ip_vs_dbg_buf[160];                                \
220                 int ip_vs_dbg_idx = 0;                                  \
221                 pr_err(msg);                                            \
222         } while (0)
223 
224 /* Only use from within IP_VS_DBG_BUF() or IP_VS_ERR_BUF macros */
225 #define IP_VS_DBG_ADDR(af, addr)                                        \
226         ip_vs_dbg_addr(af, ip_vs_dbg_buf,                               \
227                        sizeof(ip_vs_dbg_buf), addr,                     \
228                        &ip_vs_dbg_idx)
229 
230 #define IP_VS_DBG(level, msg, ...)                                      \
231         do {                                                            \
232                 if (level <= ip_vs_get_debug_level())                   \
233                         printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__);  \
234         } while (0)
235 #define IP_VS_DBG_RL(msg, ...)                                          \
236         do {                                                            \
237                 if (net_ratelimit())                                    \
238                         printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__);  \
239         } while (0)
240 #define IP_VS_DBG_PKT(level, af, pp, skb, ofs, msg)                     \
241         do {                                                            \
242                 if (level <= ip_vs_get_debug_level())                   \
243                         pp->debug_packet(af, pp, skb, ofs, msg);        \
244         } while (0)
245 #define IP_VS_DBG_RL_PKT(level, af, pp, skb, ofs, msg)                  \
246         do {                                                            \
247                 if (level <= ip_vs_get_debug_level() &&                 \
248                     net_ratelimit())                                    \
249                         pp->debug_packet(af, pp, skb, ofs, msg);        \
250         } while (0)
251 #else   /* NO DEBUGGING at ALL */
252 #define IP_VS_DBG_BUF(level, msg...)  do {} while (0)
253 #define IP_VS_ERR_BUF(msg...)  do {} while (0)
254 #define IP_VS_DBG(level, msg...)  do {} while (0)
255 #define IP_VS_DBG_RL(msg...)  do {} while (0)
256 #define IP_VS_DBG_PKT(level, af, pp, skb, ofs, msg)     do {} while (0)
257 #define IP_VS_DBG_RL_PKT(level, af, pp, skb, ofs, msg)  do {} while (0)
258 #endif
259 
260 #define IP_VS_BUG() BUG()
261 #define IP_VS_ERR_RL(msg, ...)                                          \
262         do {                                                            \
263                 if (net_ratelimit())                                    \
264                         pr_err(msg, ##__VA_ARGS__);                     \
265         } while (0)
266 
267 #ifdef CONFIG_IP_VS_DEBUG
268 #define EnterFunction(level)                                            \
269         do {                                                            \
270                 if (level <= ip_vs_get_debug_level())                   \
271                         printk(KERN_DEBUG                               \
272                                pr_fmt("Enter: %s, %s line %i\n"),       \
273                                __func__, __FILE__, __LINE__);           \
274         } while (0)
275 #define LeaveFunction(level)                                            \
276         do {                                                            \
277                 if (level <= ip_vs_get_debug_level())                   \
278                         printk(KERN_DEBUG                               \
279                                pr_fmt("Leave: %s, %s line %i\n"),       \
280                                __func__, __FILE__, __LINE__);           \
281         } while (0)
282 #else
283 #define EnterFunction(level)   do {} while (0)
284 #define LeaveFunction(level)   do {} while (0)
285 #endif
286 
287 /* The port number of FTP service (in network order). */
288 #define FTPPORT  cpu_to_be16(21)
289 #define FTPDATA  cpu_to_be16(20)
290 
291 /* TCP State Values */
292 enum {
293         IP_VS_TCP_S_NONE = 0,
294         IP_VS_TCP_S_ESTABLISHED,
295         IP_VS_TCP_S_SYN_SENT,
296         IP_VS_TCP_S_SYN_RECV,
297         IP_VS_TCP_S_FIN_WAIT,
298         IP_VS_TCP_S_TIME_WAIT,
299         IP_VS_TCP_S_CLOSE,
300         IP_VS_TCP_S_CLOSE_WAIT,
301         IP_VS_TCP_S_LAST_ACK,
302         IP_VS_TCP_S_LISTEN,
303         IP_VS_TCP_S_SYNACK,
304         IP_VS_TCP_S_LAST
305 };
306 
307 /* UDP State Values */
308 enum {
309         IP_VS_UDP_S_NORMAL,
310         IP_VS_UDP_S_LAST,
311 };
312 
313 /* ICMP State Values */
314 enum {
315         IP_VS_ICMP_S_NORMAL,
316         IP_VS_ICMP_S_LAST,
317 };
318 
319 /* SCTP State Values */
320 enum ip_vs_sctp_states {
321         IP_VS_SCTP_S_NONE,
322         IP_VS_SCTP_S_INIT1,
323         IP_VS_SCTP_S_INIT,
324         IP_VS_SCTP_S_COOKIE_SENT,
325         IP_VS_SCTP_S_COOKIE_REPLIED,
326         IP_VS_SCTP_S_COOKIE_WAIT,
327         IP_VS_SCTP_S_COOKIE,
328         IP_VS_SCTP_S_COOKIE_ECHOED,
329         IP_VS_SCTP_S_ESTABLISHED,
330         IP_VS_SCTP_S_SHUTDOWN_SENT,
331         IP_VS_SCTP_S_SHUTDOWN_RECEIVED,
332         IP_VS_SCTP_S_SHUTDOWN_ACK_SENT,
333         IP_VS_SCTP_S_REJECTED,
334         IP_VS_SCTP_S_CLOSED,
335         IP_VS_SCTP_S_LAST
336 };
337 
338 /* Connection templates use bits from state */
339 #define IP_VS_CTPL_S_NONE               0x0000
340 #define IP_VS_CTPL_S_ASSURED            0x0001
341 #define IP_VS_CTPL_S_LAST               0x0002
342 
343 /* Delta sequence info structure
344  * Each ip_vs_conn has 2 (output AND input seq. changes).
345  * Only used in the VS/NAT.
346  */
347 struct ip_vs_seq {
348         __u32                   init_seq;       /* Add delta from this seq */
349         __u32                   delta;          /* Delta in sequence numbers */
350         __u32                   previous_delta; /* Delta in sequence numbers
351                                                  * before last resized pkt */
352 };
353 
354 /* counters per cpu */
355 struct ip_vs_counters {
356         __u64           conns;          /* connections scheduled */
357         __u64           inpkts;         /* incoming packets */
358         __u64           outpkts;        /* outgoing packets */
359         __u64           inbytes;        /* incoming bytes */
360         __u64           outbytes;       /* outgoing bytes */
361 };
362 /* Stats per cpu */
363 struct ip_vs_cpu_stats {
364         struct ip_vs_counters   cnt;
365         struct u64_stats_sync   syncp;
366 };
367 
368 /* IPVS statistics objects */
369 struct ip_vs_estimator {
370         struct list_head        list;
371 
372         u64                     last_inbytes;
373         u64                     last_outbytes;
374         u64                     last_conns;
375         u64                     last_inpkts;
376         u64                     last_outpkts;
377 
378         u64                     cps;
379         u64                     inpps;
380         u64                     outpps;
381         u64                     inbps;
382         u64                     outbps;
383 };
384 
385 /*
386  * IPVS statistics object, 64-bit kernel version of struct ip_vs_stats_user
387  */
388 struct ip_vs_kstats {
389         u64                     conns;          /* connections scheduled */
390         u64                     inpkts;         /* incoming packets */
391         u64                     outpkts;        /* outgoing packets */
392         u64                     inbytes;        /* incoming bytes */
393         u64                     outbytes;       /* outgoing bytes */
394 
395         u64                     cps;            /* current connection rate */
396         u64                     inpps;          /* current in packet rate */
397         u64                     outpps;         /* current out packet rate */
398         u64                     inbps;          /* current in byte rate */
399         u64                     outbps;         /* current out byte rate */
400 };
401 
402 struct ip_vs_stats {
403         struct ip_vs_kstats     kstats;         /* kernel statistics */
404         struct ip_vs_estimator  est;            /* estimator */
405         struct ip_vs_cpu_stats __percpu *cpustats;      /* per cpu counters */
406         spinlock_t              lock;           /* spin lock */
407         struct ip_vs_kstats     kstats0;        /* reset values */
408 };
409 
410 struct dst_entry;
411 struct iphdr;
412 struct ip_vs_conn;
413 struct ip_vs_app;
414 struct sk_buff;
415 struct ip_vs_proto_data;
416 
417 struct ip_vs_protocol {
418         struct ip_vs_protocol   *next;
419         char                    *name;
420         u16                     protocol;
421         u16                     num_states;
422         int                     dont_defrag;
423 
424         void (*init)(struct ip_vs_protocol *pp);
425 
426         void (*exit)(struct ip_vs_protocol *pp);
427 
428         int (*init_netns)(struct netns_ipvs *ipvs, struct ip_vs_proto_data *pd);
429 
430         void (*exit_netns)(struct netns_ipvs *ipvs, struct ip_vs_proto_data *pd);
431 
432         int (*conn_schedule)(struct netns_ipvs *ipvs,
433                              int af, struct sk_buff *skb,
434                              struct ip_vs_proto_data *pd,
435                              int *verdict, struct ip_vs_conn **cpp,
436                              struct ip_vs_iphdr *iph);
437 
438         struct ip_vs_conn *
439         (*conn_in_get)(struct netns_ipvs *ipvs,
440                        int af,
441                        const struct sk_buff *skb,
442                        const struct ip_vs_iphdr *iph);
443 
444         struct ip_vs_conn *
445         (*conn_out_get)(struct netns_ipvs *ipvs,
446                         int af,
447                         const struct sk_buff *skb,
448                         const struct ip_vs_iphdr *iph);
449 
450         int (*snat_handler)(struct sk_buff *skb, struct ip_vs_protocol *pp,
451                             struct ip_vs_conn *cp, struct ip_vs_iphdr *iph);
452 
453         int (*dnat_handler)(struct sk_buff *skb, struct ip_vs_protocol *pp,
454                             struct ip_vs_conn *cp, struct ip_vs_iphdr *iph);
455 
456         const char *(*state_name)(int state);
457 
458         void (*state_transition)(struct ip_vs_conn *cp, int direction,
459                                  const struct sk_buff *skb,
460                                  struct ip_vs_proto_data *pd);
461 
462         int (*register_app)(struct netns_ipvs *ipvs, struct ip_vs_app *inc);
463 
464         void (*unregister_app)(struct netns_ipvs *ipvs, struct ip_vs_app *inc);
465 
466         int (*app_conn_bind)(struct ip_vs_conn *cp);
467 
468         void (*debug_packet)(int af, struct ip_vs_protocol *pp,
469                              const struct sk_buff *skb,
470                              int offset,
471                              const char *msg);
472 
473         void (*timeout_change)(struct ip_vs_proto_data *pd, int flags);
474 };
475 
476 /* protocol data per netns */
477 struct ip_vs_proto_data {
478         struct ip_vs_proto_data *next;
479         struct ip_vs_protocol   *pp;
480         int                     *timeout_table; /* protocol timeout table */
481         atomic_t                appcnt;         /* counter of proto app incs. */
482         struct tcp_states_t     *tcp_state_table;
483 };
484 
485 struct ip_vs_protocol   *ip_vs_proto_get(unsigned short proto);
486 struct ip_vs_proto_data *ip_vs_proto_data_get(struct netns_ipvs *ipvs,
487                                               unsigned short proto);
488 
489 struct ip_vs_conn_param {
490         struct netns_ipvs               *ipvs;
491         const union nf_inet_addr        *caddr;
492         const union nf_inet_addr        *vaddr;
493         __be16                          cport;
494         __be16                          vport;
495         __u16                           protocol;
496         u16                             af;
497 
498         const struct ip_vs_pe           *pe;
499         char                            *pe_data;
500         __u8                            pe_data_len;
501 };
502 
503 /* IP_VS structure allocated for each dynamically scheduled connection */
504 struct ip_vs_conn {
505         struct hlist_node       c_list;         /* hashed list heads */
506         /* Protocol, addresses and port numbers */
507         __be16                  cport;
508         __be16                  dport;
509         __be16                  vport;
510         u16                     af;             /* address family */
511         union nf_inet_addr      caddr;          /* client address */
512         union nf_inet_addr      vaddr;          /* virtual address */
513         union nf_inet_addr      daddr;          /* destination address */
514         volatile __u32          flags;          /* status flags */
515         __u16                   protocol;       /* Which protocol (TCP/UDP) */
516         __u16                   daf;            /* Address family of the dest */
517         struct netns_ipvs       *ipvs;
518 
519         /* counter and timer */
520         refcount_t              refcnt;         /* reference count */
521         struct timer_list       timer;          /* Expiration timer */
522         volatile unsigned long  timeout;        /* timeout */
523 
524         /* Flags and state transition */
525         spinlock_t              lock;           /* lock for state transition */
526         volatile __u16          state;          /* state info */
527         volatile __u16          old_state;      /* old state, to be used for
528                                                  * state transition triggerd
529                                                  * synchronization
530                                                  */
531         __u32                   fwmark;         /* Fire wall mark from skb */
532         unsigned long           sync_endtime;   /* jiffies + sent_retries */
533 
534         /* Control members */
535         struct ip_vs_conn       *control;       /* Master control connection */
536         atomic_t                n_control;      /* Number of controlled ones */
537         struct ip_vs_dest       *dest;          /* real server */
538         atomic_t                in_pkts;        /* incoming packet counter */
539 
540         /* Packet transmitter for different forwarding methods.  If it
541          * mangles the packet, it must return NF_DROP or better NF_STOLEN,
542          * otherwise this must be changed to a sk_buff **.
543          * NF_ACCEPT can be returned when destination is local.
544          */
545         int (*packet_xmit)(struct sk_buff *skb, struct ip_vs_conn *cp,
546                            struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
547 
548         /* Note: we can group the following members into a structure,
549          * in order to save more space, and the following members are
550          * only used in VS/NAT anyway
551          */
552         struct ip_vs_app        *app;           /* bound ip_vs_app object */
553         void                    *app_data;      /* Application private data */
554         struct ip_vs_seq        in_seq;         /* incoming seq. struct */
555         struct ip_vs_seq        out_seq;        /* outgoing seq. struct */
556 
557         const struct ip_vs_pe   *pe;
558         char                    *pe_data;
559         __u8                    pe_data_len;
560 
561         struct rcu_head         rcu_head;
562 };
563 
564 /* Extended internal versions of struct ip_vs_service_user and ip_vs_dest_user
565  * for IPv6 support.
566  *
567  * We need these to conveniently pass around service and destination
568  * options, but unfortunately, we also need to keep the old definitions to
569  * maintain userspace backwards compatibility for the setsockopt interface.
570  */
571 struct ip_vs_service_user_kern {
572         /* virtual service addresses */
573         u16                     af;
574         u16                     protocol;
575         union nf_inet_addr      addr;           /* virtual ip address */
576         __be16                  port;
577         u32                     fwmark;         /* firwall mark of service */
578 
579         /* virtual service options */
580         char                    *sched_name;
581         char                    *pe_name;
582         unsigned int            flags;          /* virtual service flags */
583         unsigned int            timeout;        /* persistent timeout in sec */
584         __be32                  netmask;        /* persistent netmask or plen */
585 };
586 
587 
588 struct ip_vs_dest_user_kern {
589         /* destination server address */
590         union nf_inet_addr      addr;
591         __be16                  port;
592 
593         /* real server options */
594         unsigned int            conn_flags;     /* connection flags */
595         int                     weight;         /* destination weight */
596 
597         /* thresholds for active connections */
598         u32                     u_threshold;    /* upper threshold */
599         u32                     l_threshold;    /* lower threshold */
600 
601         /* Address family of addr */
602         u16                     af;
603 
604         u16                     tun_type;       /* tunnel type */
605         __be16                  tun_port;       /* tunnel port */
606         u16                     tun_flags;      /* tunnel flags */
607 };
608 
609 
610 /*
611  * The information about the virtual service offered to the net and the
612  * forwarding entries.
613  */
614 struct ip_vs_service {
615         struct hlist_node       s_list;   /* for normal service table */
616         struct hlist_node       f_list;   /* for fwmark-based service table */
617         atomic_t                refcnt;   /* reference counter */
618 
619         u16                     af;       /* address family */
620         __u16                   protocol; /* which protocol (TCP/UDP) */
621         union nf_inet_addr      addr;     /* IP address for virtual service */
622         __be16                  port;     /* port number for the service */
623         __u32                   fwmark;   /* firewall mark of the service */
624         unsigned int            flags;    /* service status flags */
625         unsigned int            timeout;  /* persistent timeout in ticks */
626         __be32                  netmask;  /* grouping granularity, mask/plen */
627         struct netns_ipvs       *ipvs;
628 
629         struct list_head        destinations;  /* real server d-linked list */
630         __u32                   num_dests;     /* number of servers */
631         struct ip_vs_stats      stats;         /* statistics for the service */
632 
633         /* for scheduling */
634         struct ip_vs_scheduler __rcu *scheduler; /* bound scheduler object */
635         spinlock_t              sched_lock;    /* lock sched_data */
636         void                    *sched_data;   /* scheduler application data */
637 
638         /* alternate persistence engine */
639         struct ip_vs_pe __rcu   *pe;
640         int                     conntrack_afmask;
641 
642         struct rcu_head         rcu_head;
643 };
644 
645 /* Information for cached dst */
646 struct ip_vs_dest_dst {
647         struct dst_entry        *dst_cache;     /* destination cache entry */
648         u32                     dst_cookie;
649         union nf_inet_addr      dst_saddr;
650         struct rcu_head         rcu_head;
651 };
652 
653 /* The real server destination forwarding entry with ip address, port number,
654  * and so on.
655  */
656 struct ip_vs_dest {
657         struct list_head        n_list;   /* for the dests in the service */
658         struct hlist_node       d_list;   /* for table with all the dests */
659 
660         u16                     af;             /* address family */
661         __be16                  port;           /* port number of the server */
662         union nf_inet_addr      addr;           /* IP address of the server */
663         volatile unsigned int   flags;          /* dest status flags */
664         atomic_t                conn_flags;     /* flags to copy to conn */
665         atomic_t                weight;         /* server weight */
666         atomic_t                last_weight;    /* server latest weight */
667         __u16                   tun_type;       /* tunnel type */
668         __be16                  tun_port;       /* tunnel port */
669         __u16                   tun_flags;      /* tunnel flags */
670 
671         refcount_t              refcnt;         /* reference counter */
672         struct ip_vs_stats      stats;          /* statistics */
673         unsigned long           idle_start;     /* start time, jiffies */
674 
675         /* connection counters and thresholds */
676         atomic_t                activeconns;    /* active connections */
677         atomic_t                inactconns;     /* inactive connections */
678         atomic_t                persistconns;   /* persistent connections */
679         __u32                   u_threshold;    /* upper threshold */
680         __u32                   l_threshold;    /* lower threshold */
681 
682         /* for destination cache */
683         spinlock_t              dst_lock;       /* lock of dst_cache */
684         struct ip_vs_dest_dst __rcu *dest_dst;  /* cached dst info */
685 
686         /* for virtual service */
687         struct ip_vs_service __rcu *svc;        /* service it belongs to */
688         __u16                   protocol;       /* which protocol (TCP/UDP) */
689         __be16                  vport;          /* virtual port number */
690         union nf_inet_addr      vaddr;          /* virtual IP address */
691         __u32                   vfwmark;        /* firewall mark of service */
692 
693         struct list_head        t_list;         /* in dest_trash */
694         unsigned int            in_rs_table:1;  /* we are in rs_table */
695 };
696 
697 /* The scheduler object */
698 struct ip_vs_scheduler {
699         struct list_head        n_list;         /* d-linked list head */
700         char                    *name;          /* scheduler name */
701         atomic_t                refcnt;         /* reference counter */
702         struct module           *module;        /* THIS_MODULE/NULL */
703 
704         /* scheduler initializing service */
705         int (*init_service)(struct ip_vs_service *svc);
706         /* scheduling service finish */
707         void (*done_service)(struct ip_vs_service *svc);
708         /* dest is linked */
709         int (*add_dest)(struct ip_vs_service *svc, struct ip_vs_dest *dest);
710         /* dest is unlinked */
711         int (*del_dest)(struct ip_vs_service *svc, struct ip_vs_dest *dest);
712         /* dest is updated */
713         int (*upd_dest)(struct ip_vs_service *svc, struct ip_vs_dest *dest);
714 
715         /* selecting a server from the given service */
716         struct ip_vs_dest* (*schedule)(struct ip_vs_service *svc,
717                                        const struct sk_buff *skb,
718                                        struct ip_vs_iphdr *iph);
719 };
720 
721 /* The persistence engine object */
722 struct ip_vs_pe {
723         struct list_head        n_list;         /* d-linked list head */
724         char                    *name;          /* scheduler name */
725         atomic_t                refcnt;         /* reference counter */
726         struct module           *module;        /* THIS_MODULE/NULL */
727 
728         /* get the connection template, if any */
729         int (*fill_param)(struct ip_vs_conn_param *p, struct sk_buff *skb);
730         bool (*ct_match)(const struct ip_vs_conn_param *p,
731                          struct ip_vs_conn *ct);
732         u32 (*hashkey_raw)(const struct ip_vs_conn_param *p, u32 initval,
733                            bool inverse);
734         int (*show_pe_data)(const struct ip_vs_conn *cp, char *buf);
735         /* create connections for real-server outgoing packets */
736         struct ip_vs_conn* (*conn_out)(struct ip_vs_service *svc,
737                                        struct ip_vs_dest *dest,
738                                        struct sk_buff *skb,
739                                        const struct ip_vs_iphdr *iph,
740                                        __be16 dport, __be16 cport);
741 };
742 
743 /* The application module object (a.k.a. app incarnation) */
744 struct ip_vs_app {
745         struct list_head        a_list;         /* member in app list */
746         int                     type;           /* IP_VS_APP_TYPE_xxx */
747         char                    *name;          /* application module name */
748         __u16                   protocol;
749         struct module           *module;        /* THIS_MODULE/NULL */
750         struct list_head        incs_list;      /* list of incarnations */
751 
752         /* members for application incarnations */
753         struct list_head        p_list;         /* member in proto app list */
754         struct ip_vs_app        *app;           /* its real application */
755         __be16                  port;           /* port number in net order */
756         atomic_t                usecnt;         /* usage counter */
757         struct rcu_head         rcu_head;
758 
759         /* output hook: Process packet in inout direction, diff set for TCP.
760          * Return: 0=Error, 1=Payload Not Mangled/Mangled but checksum is ok,
761          *         2=Mangled but checksum was not updated
762          */
763         int (*pkt_out)(struct ip_vs_app *, struct ip_vs_conn *,
764                        struct sk_buff *, int *diff, struct ip_vs_iphdr *ipvsh);
765 
766         /* input hook: Process packet in outin direction, diff set for TCP.
767          * Return: 0=Error, 1=Payload Not Mangled/Mangled but checksum is ok,
768          *         2=Mangled but checksum was not updated
769          */
770         int (*pkt_in)(struct ip_vs_app *, struct ip_vs_conn *,
771                       struct sk_buff *, int *diff, struct ip_vs_iphdr *ipvsh);
772 
773         /* ip_vs_app initializer */
774         int (*init_conn)(struct ip_vs_app *, struct ip_vs_conn *);
775 
776         /* ip_vs_app finish */
777         int (*done_conn)(struct ip_vs_app *, struct ip_vs_conn *);
778 
779 
780         /* not used now */
781         int (*bind_conn)(struct ip_vs_app *, struct ip_vs_conn *,
782                          struct ip_vs_protocol *);
783 
784         void (*unbind_conn)(struct ip_vs_app *, struct ip_vs_conn *);
785 
786         int *                   timeout_table;
787         int *                   timeouts;
788         int                     timeouts_size;
789 
790         int (*conn_schedule)(struct sk_buff *skb, struct ip_vs_app *app,
791                              int *verdict, struct ip_vs_conn **cpp);
792 
793         struct ip_vs_conn *
794         (*conn_in_get)(const struct sk_buff *skb, struct ip_vs_app *app,
795                        const struct iphdr *iph, int inverse);
796 
797         struct ip_vs_conn *
798         (*conn_out_get)(const struct sk_buff *skb, struct ip_vs_app *app,
799                         const struct iphdr *iph, int inverse);
800 
801         int (*state_transition)(struct ip_vs_conn *cp, int direction,
802                                 const struct sk_buff *skb,
803                                 struct ip_vs_app *app);
804 
805         void (*timeout_change)(struct ip_vs_app *app, int flags);
806 };
807 
808 struct ipvs_master_sync_state {
809         struct list_head        sync_queue;
810         struct ip_vs_sync_buff  *sync_buff;
811         unsigned long           sync_queue_len;
812         unsigned int            sync_queue_delay;
813         struct delayed_work     master_wakeup_work;
814         struct netns_ipvs       *ipvs;
815 };
816 
817 struct ip_vs_sync_thread_data;
818 
819 /* How much time to keep dests in trash */
820 #define IP_VS_DEST_TRASH_PERIOD         (120 * HZ)
821 
822 struct ipvs_sync_daemon_cfg {
823         union nf_inet_addr      mcast_group;
824         int                     syncid;
825         u16                     sync_maxlen;
826         u16                     mcast_port;
827         u8                      mcast_af;
828         u8                      mcast_ttl;
829         /* multicast interface name */
830         char                    mcast_ifn[IP_VS_IFNAME_MAXLEN];
831 };
832 
833 /* IPVS in network namespace */
834 struct netns_ipvs {
835         int                     gen;            /* Generation */
836         int                     enable;         /* enable like nf_hooks do */
837         /* Hash table: for real service lookups */
838         #define IP_VS_RTAB_BITS 4
839         #define IP_VS_RTAB_SIZE (1 << IP_VS_RTAB_BITS)
840         #define IP_VS_RTAB_MASK (IP_VS_RTAB_SIZE - 1)
841 
842         struct hlist_head       rs_table[IP_VS_RTAB_SIZE];
843         /* ip_vs_app */
844         struct list_head        app_list;
845         /* ip_vs_proto */
846         #define IP_VS_PROTO_TAB_SIZE    32      /* must be power of 2 */
847         struct ip_vs_proto_data *proto_data_table[IP_VS_PROTO_TAB_SIZE];
848         /* ip_vs_proto_tcp */
849 #ifdef CONFIG_IP_VS_PROTO_TCP
850         #define TCP_APP_TAB_BITS        4
851         #define TCP_APP_TAB_SIZE        (1 << TCP_APP_TAB_BITS)
852         #define TCP_APP_TAB_MASK        (TCP_APP_TAB_SIZE - 1)
853         struct list_head        tcp_apps[TCP_APP_TAB_SIZE];
854 #endif
855         /* ip_vs_proto_udp */
856 #ifdef CONFIG_IP_VS_PROTO_UDP
857         #define UDP_APP_TAB_BITS        4
858         #define UDP_APP_TAB_SIZE        (1 << UDP_APP_TAB_BITS)
859         #define UDP_APP_TAB_MASK        (UDP_APP_TAB_SIZE - 1)
860         struct list_head        udp_apps[UDP_APP_TAB_SIZE];
861 #endif
862         /* ip_vs_proto_sctp */
863 #ifdef CONFIG_IP_VS_PROTO_SCTP
864         #define SCTP_APP_TAB_BITS       4
865         #define SCTP_APP_TAB_SIZE       (1 << SCTP_APP_TAB_BITS)
866         #define SCTP_APP_TAB_MASK       (SCTP_APP_TAB_SIZE - 1)
867         /* Hash table for SCTP application incarnations  */
868         struct list_head        sctp_apps[SCTP_APP_TAB_SIZE];
869 #endif
870         /* ip_vs_conn */
871         atomic_t                conn_count;      /* connection counter */
872 
873         /* ip_vs_ctl */
874         struct ip_vs_stats              tot_stats;  /* Statistics & est. */
875 
876         int                     num_services;    /* no of virtual services */
877 
878         /* Trash for destinations */
879         struct list_head        dest_trash;
880         spinlock_t              dest_trash_lock;
881         struct timer_list       dest_trash_timer; /* expiration timer */
882         /* Service counters */
883         atomic_t                ftpsvc_counter;
884         atomic_t                nullsvc_counter;
885         atomic_t                conn_out_counter;
886 
887 #ifdef CONFIG_SYSCTL
888         /* 1/rate drop and drop-entry variables */
889         struct delayed_work     defense_work;   /* Work handler */
890         int                     drop_rate;
891         int                     drop_counter;
892         int                     old_secure_tcp;
893         atomic_t                dropentry;
894         /* locks in ctl.c */
895         spinlock_t              dropentry_lock;  /* drop entry handling */
896         spinlock_t              droppacket_lock; /* drop packet handling */
897         spinlock_t              securetcp_lock;  /* state and timeout tables */
898 
899         /* sys-ctl struct */
900         struct ctl_table_header *sysctl_hdr;
901         struct ctl_table        *sysctl_tbl;
902 #endif
903 
904         /* sysctl variables */
905         int                     sysctl_amemthresh;
906         int                     sysctl_am_droprate;
907         int                     sysctl_drop_entry;
908         int                     sysctl_drop_packet;
909         int                     sysctl_secure_tcp;
910 #ifdef CONFIG_IP_VS_NFCT
911         int                     sysctl_conntrack;
912 #endif
913         int                     sysctl_snat_reroute;
914         int                     sysctl_sync_ver;
915         int                     sysctl_sync_ports;
916         int                     sysctl_sync_persist_mode;
917         unsigned long           sysctl_sync_qlen_max;
918         int                     sysctl_sync_sock_size;
919         int                     sysctl_cache_bypass;
920         int                     sysctl_expire_nodest_conn;
921         int                     sysctl_sloppy_tcp;
922         int                     sysctl_sloppy_sctp;
923         int                     sysctl_expire_quiescent_template;
924         int                     sysctl_sync_threshold[2];
925         unsigned int            sysctl_sync_refresh_period;
926         int                     sysctl_sync_retries;
927         int                     sysctl_nat_icmp_send;
928         int                     sysctl_pmtu_disc;
929         int                     sysctl_backup_only;
930         int                     sysctl_conn_reuse_mode;
931         int                     sysctl_schedule_icmp;
932         int                     sysctl_ignore_tunneled;
933 
934         /* ip_vs_lblc */
935         int                     sysctl_lblc_expiration;
936         struct ctl_table_header *lblc_ctl_header;
937         struct ctl_table        *lblc_ctl_table;
938         /* ip_vs_lblcr */
939         int                     sysctl_lblcr_expiration;
940         struct ctl_table_header *lblcr_ctl_header;
941         struct ctl_table        *lblcr_ctl_table;
942         /* ip_vs_est */
943         struct list_head        est_list;       /* estimator list */
944         spinlock_t              est_lock;
945         struct timer_list       est_timer;      /* Estimation timer */
946         /* ip_vs_sync */
947         spinlock_t              sync_lock;
948         struct ipvs_master_sync_state *ms;
949         spinlock_t              sync_buff_lock;
950         struct ip_vs_sync_thread_data *master_tinfo;
951         struct ip_vs_sync_thread_data *backup_tinfo;
952         int                     threads_mask;
953         volatile int            sync_state;
954         struct mutex            sync_mutex;
955         struct ipvs_sync_daemon_cfg     mcfg;   /* Master Configuration */
956         struct ipvs_sync_daemon_cfg     bcfg;   /* Backup Configuration */
957         /* net name space ptr */
958         struct net              *net;            /* Needed by timer routines */
959         /* Number of heterogeneous destinations, needed becaus heterogeneous
960          * are not supported when synchronization is enabled.
961          */
962         unsigned int            mixed_address_family_dests;
963 };
964 
965 #define DEFAULT_SYNC_THRESHOLD  3
966 #define DEFAULT_SYNC_PERIOD     50
967 #define DEFAULT_SYNC_VER        1
968 #define DEFAULT_SLOPPY_TCP      0
969 #define DEFAULT_SLOPPY_SCTP     0
970 #define DEFAULT_SYNC_REFRESH_PERIOD     (0U * HZ)
971 #define DEFAULT_SYNC_RETRIES            0
972 #define IPVS_SYNC_WAKEUP_RATE   8
973 #define IPVS_SYNC_QLEN_MAX      (IPVS_SYNC_WAKEUP_RATE * 4)
974 #define IPVS_SYNC_SEND_DELAY    (HZ / 50)
975 #define IPVS_SYNC_CHECK_PERIOD  HZ
976 #define IPVS_SYNC_FLUSH_TIME    (HZ * 2)
977 #define IPVS_SYNC_PORTS_MAX     (1 << 6)
978 
979 #ifdef CONFIG_SYSCTL
980 
981 static inline int sysctl_sync_threshold(struct netns_ipvs *ipvs)
982 {
983         return ipvs->sysctl_sync_threshold[0];
984 }
985 
986 static inline int sysctl_sync_period(struct netns_ipvs *ipvs)
987 {
988         return READ_ONCE(ipvs->sysctl_sync_threshold[1]);
989 }
990 
991 static inline unsigned int sysctl_sync_refresh_period(struct netns_ipvs *ipvs)
992 {
993         return READ_ONCE(ipvs->sysctl_sync_refresh_period);
994 }
995 
996 static inline int sysctl_sync_retries(struct netns_ipvs *ipvs)
997 {
998         return ipvs->sysctl_sync_retries;
999 }
1000 
1001 static inline int sysctl_sync_ver(struct netns_ipvs *ipvs)
1002 {
1003         return ipvs->sysctl_sync_ver;
1004 }
1005 
1006 static inline int sysctl_sloppy_tcp(struct netns_ipvs *ipvs)
1007 {
1008         return ipvs->sysctl_sloppy_tcp;
1009 }
1010 
1011 static inline int sysctl_sloppy_sctp(struct netns_ipvs *ipvs)
1012 {
1013         return ipvs->sysctl_sloppy_sctp;
1014 }
1015 
1016 static inline int sysctl_sync_ports(struct netns_ipvs *ipvs)
1017 {
1018         return READ_ONCE(ipvs->sysctl_sync_ports);
1019 }
1020 
1021 static inline int sysctl_sync_persist_mode(struct netns_ipvs *ipvs)
1022 {
1023         return ipvs->sysctl_sync_persist_mode;
1024 }
1025 
1026 static inline unsigned long sysctl_sync_qlen_max(struct netns_ipvs *ipvs)
1027 {
1028         return ipvs->sysctl_sync_qlen_max;
1029 }
1030 
1031 static inline int sysctl_sync_sock_size(struct netns_ipvs *ipvs)
1032 {
1033         return ipvs->sysctl_sync_sock_size;
1034 }
1035 
1036 static inline int sysctl_pmtu_disc(struct netns_ipvs *ipvs)
1037 {
1038         return ipvs->sysctl_pmtu_disc;
1039 }
1040 
1041 static inline int sysctl_backup_only(struct netns_ipvs *ipvs)
1042 {
1043         return ipvs->sync_state & IP_VS_STATE_BACKUP &&
1044                ipvs->sysctl_backup_only;
1045 }
1046 
1047 static inline int sysctl_conn_reuse_mode(struct netns_ipvs *ipvs)
1048 {
1049         return ipvs->sysctl_conn_reuse_mode;
1050 }
1051 
1052 static inline int sysctl_schedule_icmp(struct netns_ipvs *ipvs)
1053 {
1054         return ipvs->sysctl_schedule_icmp;
1055 }
1056 
1057 static inline int sysctl_ignore_tunneled(struct netns_ipvs *ipvs)
1058 {
1059         return ipvs->sysctl_ignore_tunneled;
1060 }
1061 
1062 static inline int sysctl_cache_bypass(struct netns_ipvs *ipvs)
1063 {
1064         return ipvs->sysctl_cache_bypass;
1065 }
1066 
1067 #else
1068 
1069 static inline int sysctl_sync_threshold(struct netns_ipvs *ipvs)
1070 {
1071         return DEFAULT_SYNC_THRESHOLD;
1072 }
1073 
1074 static inline int sysctl_sync_period(struct netns_ipvs *ipvs)
1075 {
1076         return DEFAULT_SYNC_PERIOD;
1077 }
1078 
1079 static inline unsigned int sysctl_sync_refresh_period(struct netns_ipvs *ipvs)
1080 {
1081         return DEFAULT_SYNC_REFRESH_PERIOD;
1082 }
1083 
1084 static inline int sysctl_sync_retries(struct netns_ipvs *ipvs)
1085 {
1086         return DEFAULT_SYNC_RETRIES & 3;
1087 }
1088 
1089 static inline int sysctl_sync_ver(struct netns_ipvs *ipvs)
1090 {
1091         return DEFAULT_SYNC_VER;
1092 }
1093 
1094 static inline int sysctl_sloppy_tcp(struct netns_ipvs *ipvs)
1095 {
1096         return DEFAULT_SLOPPY_TCP;
1097 }
1098 
1099 static inline int sysctl_sloppy_sctp(struct netns_ipvs *ipvs)
1100 {
1101         return DEFAULT_SLOPPY_SCTP;
1102 }
1103 
1104 static inline int sysctl_sync_ports(struct netns_ipvs *ipvs)
1105 {
1106         return 1;
1107 }
1108 
1109 static inline int sysctl_sync_persist_mode(struct netns_ipvs *ipvs)
1110 {
1111         return 0;
1112 }
1113 
1114 static inline unsigned long sysctl_sync_qlen_max(struct netns_ipvs *ipvs)
1115 {
1116         return IPVS_SYNC_QLEN_MAX;
1117 }
1118 
1119 static inline int sysctl_sync_sock_size(struct netns_ipvs *ipvs)
1120 {
1121         return 0;
1122 }
1123 
1124 static inline int sysctl_pmtu_disc(struct netns_ipvs *ipvs)
1125 {
1126         return 1;
1127 }
1128 
1129 static inline int sysctl_backup_only(struct netns_ipvs *ipvs)
1130 {
1131         return 0;
1132 }
1133 
1134 static inline int sysctl_conn_reuse_mode(struct netns_ipvs *ipvs)
1135 {
1136         return 1;
1137 }
1138 
1139 static inline int sysctl_schedule_icmp(struct netns_ipvs *ipvs)
1140 {
1141         return 0;
1142 }
1143 
1144 static inline int sysctl_ignore_tunneled(struct netns_ipvs *ipvs)
1145 {
1146         return 0;
1147 }
1148 
1149 static inline int sysctl_cache_bypass(struct netns_ipvs *ipvs)
1150 {
1151         return 0;
1152 }
1153 
1154 #endif
1155 
1156 /* IPVS core functions
1157  * (from ip_vs_core.c)
1158  */
1159 const char *ip_vs_proto_name(unsigned int proto);
1160 void ip_vs_init_hash_table(struct list_head *table, int rows);
1161 struct ip_vs_conn *ip_vs_new_conn_out(struct ip_vs_service *svc,
1162                                       struct ip_vs_dest *dest,
1163                                       struct sk_buff *skb,
1164                                       const struct ip_vs_iphdr *iph,
1165                                       __be16 dport,
1166                                       __be16 cport);
1167 #define IP_VS_INIT_HASH_TABLE(t) ip_vs_init_hash_table((t), ARRAY_SIZE((t)))
1168 
1169 #define IP_VS_APP_TYPE_FTP      1
1170 
1171 /* ip_vs_conn handling functions
1172  * (from ip_vs_conn.c)
1173  */
1174 enum {
1175         IP_VS_DIR_INPUT = 0,
1176         IP_VS_DIR_OUTPUT,
1177         IP_VS_DIR_INPUT_ONLY,
1178         IP_VS_DIR_LAST,
1179 };
1180 
1181 static inline void ip_vs_conn_fill_param(struct netns_ipvs *ipvs, int af, int protocol,
1182                                          const union nf_inet_addr *caddr,
1183                                          __be16 cport,
1184                                          const union nf_inet_addr *vaddr,
1185                                          __be16 vport,
1186                                          struct ip_vs_conn_param *p)
1187 {
1188         p->ipvs = ipvs;
1189         p->af = af;
1190         p->protocol = protocol;
1191         p->caddr = caddr;
1192         p->cport = cport;
1193         p->vaddr = vaddr;
1194         p->vport = vport;
1195         p->pe = NULL;
1196         p->pe_data = NULL;
1197 }
1198 
1199 struct ip_vs_conn *ip_vs_conn_in_get(const struct ip_vs_conn_param *p);
1200 struct ip_vs_conn *ip_vs_ct_in_get(const struct ip_vs_conn_param *p);
1201 
1202 struct ip_vs_conn * ip_vs_conn_in_get_proto(struct netns_ipvs *ipvs, int af,
1203                                             const struct sk_buff *skb,
1204                                             const struct ip_vs_iphdr *iph);
1205 
1206 struct ip_vs_conn *ip_vs_conn_out_get(const struct ip_vs_conn_param *p);
1207 
1208 struct ip_vs_conn * ip_vs_conn_out_get_proto(struct netns_ipvs *ipvs, int af,
1209                                              const struct sk_buff *skb,
1210                                              const struct ip_vs_iphdr *iph);
1211 
1212 /* Get reference to gain full access to conn.
1213  * By default, RCU read-side critical sections have access only to
1214  * conn fields and its PE data, see ip_vs_conn_rcu_free() for reference.
1215  */
1216 static inline bool __ip_vs_conn_get(struct ip_vs_conn *cp)
1217 {
1218         return refcount_inc_not_zero(&cp->refcnt);
1219 }
1220 
1221 /* put back the conn without restarting its timer */
1222 static inline void __ip_vs_conn_put(struct ip_vs_conn *cp)
1223 {
1224         smp_mb__before_atomic();
1225         refcount_dec(&cp->refcnt);
1226 }
1227 void ip_vs_conn_put(struct ip_vs_conn *cp);
1228 void ip_vs_conn_fill_cport(struct ip_vs_conn *cp, __be16 cport);
1229 
1230 struct ip_vs_conn *ip_vs_conn_new(const struct ip_vs_conn_param *p, int dest_af,
1231                                   const union nf_inet_addr *daddr,
1232                                   __be16 dport, unsigned int flags,
1233                                   struct ip_vs_dest *dest, __u32 fwmark);
1234 void ip_vs_conn_expire_now(struct ip_vs_conn *cp);
1235 
1236 const char *ip_vs_state_name(const struct ip_vs_conn *cp);
1237 
1238 void ip_vs_tcp_conn_listen(struct ip_vs_conn *cp);
1239 int ip_vs_check_template(struct ip_vs_conn *ct, struct ip_vs_dest *cdest);
1240 void ip_vs_random_dropentry(struct netns_ipvs *ipvs);
1241 int ip_vs_conn_init(void);
1242 void ip_vs_conn_cleanup(void);
1243 
1244 static inline void ip_vs_control_del(struct ip_vs_conn *cp)
1245 {
1246         struct ip_vs_conn *ctl_cp = cp->control;
1247         if (!ctl_cp) {
1248                 IP_VS_ERR_BUF("request control DEL for uncontrolled: "
1249                               "%s:%d to %s:%d\n",
1250                               IP_VS_DBG_ADDR(cp->af, &cp->caddr),
1251                               ntohs(cp->cport),
1252                               IP_VS_DBG_ADDR(cp->af, &cp->vaddr),
1253                               ntohs(cp->vport));
1254 
1255                 return;
1256         }
1257 
1258         IP_VS_DBG_BUF(7, "DELeting control for: "
1259                       "cp.dst=%s:%d ctl_cp.dst=%s:%d\n",
1260                       IP_VS_DBG_ADDR(cp->af, &cp->caddr),
1261                       ntohs(cp->cport),
1262                       IP_VS_DBG_ADDR(cp->af, &ctl_cp->caddr),
1263                       ntohs(ctl_cp->cport));
1264 
1265         cp->control = NULL;
1266         if (atomic_read(&ctl_cp->n_control) == 0) {
1267                 IP_VS_ERR_BUF("BUG control DEL with n=0 : "
1268                               "%s:%d to %s:%d\n",
1269                               IP_VS_DBG_ADDR(cp->af, &cp->caddr),
1270                               ntohs(cp->cport),
1271                               IP_VS_DBG_ADDR(cp->af, &cp->vaddr),
1272                               ntohs(cp->vport));
1273 
1274                 return;
1275         }
1276         atomic_dec(&ctl_cp->n_control);
1277 }
1278 
1279 static inline void
1280 ip_vs_control_add(struct ip_vs_conn *cp, struct ip_vs_conn *ctl_cp)
1281 {
1282         if (cp->control) {
1283                 IP_VS_ERR_BUF("request control ADD for already controlled: "
1284                               "%s:%d to %s:%d\n",
1285                               IP_VS_DBG_ADDR(cp->af, &cp->caddr),
1286                               ntohs(cp->cport),
1287                               IP_VS_DBG_ADDR(cp->af, &cp->vaddr),
1288                               ntohs(cp->vport));
1289 
1290                 ip_vs_control_del(cp);
1291         }
1292 
1293         IP_VS_DBG_BUF(7, "ADDing control for: "
1294                       "cp.dst=%s:%d ctl_cp.dst=%s:%d\n",
1295                       IP_VS_DBG_ADDR(cp->af, &cp->caddr),
1296                       ntohs(cp->cport),
1297                       IP_VS_DBG_ADDR(cp->af, &ctl_cp->caddr),
1298                       ntohs(ctl_cp->cport));
1299 
1300         cp->control = ctl_cp;
1301         atomic_inc(&ctl_cp->n_control);
1302 }
1303 
1304 /* Mark our template as assured */
1305 static inline void
1306 ip_vs_control_assure_ct(struct ip_vs_conn *cp)
1307 {
1308         struct ip_vs_conn *ct = cp->control;
1309 
1310         if (ct && !(ct->state & IP_VS_CTPL_S_ASSURED) &&
1311             (ct->flags & IP_VS_CONN_F_TEMPLATE))
1312                 ct->state |= IP_VS_CTPL_S_ASSURED;
1313 }
1314 
1315 /* IPVS netns init & cleanup functions */
1316 int ip_vs_estimator_net_init(struct netns_ipvs *ipvs);
1317 int ip_vs_control_net_init(struct netns_ipvs *ipvs);
1318 int ip_vs_protocol_net_init(struct netns_ipvs *ipvs);
1319 int ip_vs_app_net_init(struct netns_ipvs *ipvs);
1320 int ip_vs_conn_net_init(struct netns_ipvs *ipvs);
1321 int ip_vs_sync_net_init(struct netns_ipvs *ipvs);
1322 void ip_vs_conn_net_cleanup(struct netns_ipvs *ipvs);
1323 void ip_vs_app_net_cleanup(struct netns_ipvs *ipvs);
1324 void ip_vs_protocol_net_cleanup(struct netns_ipvs *ipvs);
1325 void ip_vs_control_net_cleanup(struct netns_ipvs *ipvs);
1326 void ip_vs_estimator_net_cleanup(struct netns_ipvs *ipvs);
1327 void ip_vs_sync_net_cleanup(struct netns_ipvs *ipvs);
1328 void ip_vs_service_nets_cleanup(struct list_head *net_list);
1329 
1330 /* IPVS application functions
1331  * (from ip_vs_app.c)
1332  */
1333 #define IP_VS_APP_MAX_PORTS  8
1334 struct ip_vs_app *register_ip_vs_app(struct netns_ipvs *ipvs, struct ip_vs_app *app);
1335 void unregister_ip_vs_app(struct netns_ipvs *ipvs, struct ip_vs_app *app);
1336 int ip_vs_bind_app(struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
1337 void ip_vs_unbind_app(struct ip_vs_conn *cp);
1338 int register_ip_vs_app_inc(struct netns_ipvs *ipvs, struct ip_vs_app *app, __u16 proto,
1339                            __u16 port);
1340 int ip_vs_app_inc_get(struct ip_vs_app *inc);
1341 void ip_vs_app_inc_put(struct ip_vs_app *inc);
1342 
1343 int ip_vs_app_pkt_out(struct ip_vs_conn *, struct sk_buff *skb,
1344                       struct ip_vs_iphdr *ipvsh);
1345 int ip_vs_app_pkt_in(struct ip_vs_conn *, struct sk_buff *skb,
1346                      struct ip_vs_iphdr *ipvsh);
1347 
1348 int register_ip_vs_pe(struct ip_vs_pe *pe);
1349 int unregister_ip_vs_pe(struct ip_vs_pe *pe);
1350 struct ip_vs_pe *ip_vs_pe_getbyname(const char *name);
1351 struct ip_vs_pe *__ip_vs_pe_getbyname(const char *pe_name);
1352 
1353 /* Use a #define to avoid all of module.h just for these trivial ops */
1354 #define ip_vs_pe_get(pe)                        \
1355         if (pe && pe->module)                   \
1356                 __module_get(pe->module);
1357 
1358 #define ip_vs_pe_put(pe)                        \
1359         if (pe && pe->module)                   \
1360                 module_put(pe->module);
1361 
1362 /* IPVS protocol functions (from ip_vs_proto.c) */
1363 int ip_vs_protocol_init(void);
1364 void ip_vs_protocol_cleanup(void);
1365 void ip_vs_protocol_timeout_change(struct netns_ipvs *ipvs, int flags);
1366 int *ip_vs_create_timeout_table(int *table, int size);
1367 void ip_vs_tcpudp_debug_packet(int af, struct ip_vs_protocol *pp,
1368                                const struct sk_buff *skb, int offset,
1369                                const char *msg);
1370 
1371 extern struct ip_vs_protocol ip_vs_protocol_tcp;
1372 extern struct ip_vs_protocol ip_vs_protocol_udp;
1373 extern struct ip_vs_protocol ip_vs_protocol_icmp;
1374 extern struct ip_vs_protocol ip_vs_protocol_esp;
1375 extern struct ip_vs_protocol ip_vs_protocol_ah;
1376 extern struct ip_vs_protocol ip_vs_protocol_sctp;
1377 
1378 /* Registering/unregistering scheduler functions
1379  * (from ip_vs_sched.c)
1380  */
1381 int register_ip_vs_scheduler(struct ip_vs_scheduler *scheduler);
1382 int unregister_ip_vs_scheduler(struct ip_vs_scheduler *scheduler);
1383 int ip_vs_bind_scheduler(struct ip_vs_service *svc,
1384                          struct ip_vs_scheduler *scheduler);
1385 void ip_vs_unbind_scheduler(struct ip_vs_service *svc,
1386                             struct ip_vs_scheduler *sched);
1387 struct ip_vs_scheduler *ip_vs_scheduler_get(const char *sched_name);
1388 void ip_vs_scheduler_put(struct ip_vs_scheduler *scheduler);
1389 struct ip_vs_conn *
1390 ip_vs_schedule(struct ip_vs_service *svc, struct sk_buff *skb,
1391                struct ip_vs_proto_data *pd, int *ignored,
1392                struct ip_vs_iphdr *iph);
1393 int ip_vs_leave(struct ip_vs_service *svc, struct sk_buff *skb,
1394                 struct ip_vs_proto_data *pd, struct ip_vs_iphdr *iph);
1395 
1396 void ip_vs_scheduler_err(struct ip_vs_service *svc, const char *msg);
1397 
1398 /* IPVS control data and functions (from ip_vs_ctl.c) */
1399 extern struct ip_vs_stats ip_vs_stats;
1400 extern int sysctl_ip_vs_sync_ver;
1401 
1402 struct ip_vs_service *
1403 ip_vs_service_find(struct netns_ipvs *ipvs, int af, __u32 fwmark, __u16 protocol,
1404                   const union nf_inet_addr *vaddr, __be16 vport);
1405 
1406 bool ip_vs_has_real_service(struct netns_ipvs *ipvs, int af, __u16 protocol,
1407                             const union nf_inet_addr *daddr, __be16 dport);
1408 
1409 struct ip_vs_dest *
1410 ip_vs_find_real_service(struct netns_ipvs *ipvs, int af, __u16 protocol,
1411                         const union nf_inet_addr *daddr, __be16 dport);
1412 struct ip_vs_dest *ip_vs_find_tunnel(struct netns_ipvs *ipvs, int af,
1413                                      const union nf_inet_addr *daddr,
1414                                      __be16 tun_port);
1415 
1416 int ip_vs_use_count_inc(void);
1417 void ip_vs_use_count_dec(void);
1418 int ip_vs_register_nl_ioctl(void);
1419 void ip_vs_unregister_nl_ioctl(void);
1420 int ip_vs_control_init(void);
1421 void ip_vs_control_cleanup(void);
1422 struct ip_vs_dest *
1423 ip_vs_find_dest(struct netns_ipvs *ipvs, int svc_af, int dest_af,
1424                 const union nf_inet_addr *daddr, __be16 dport,
1425                 const union nf_inet_addr *vaddr, __be16 vport,
1426                 __u16 protocol, __u32 fwmark, __u32 flags);
1427 void ip_vs_try_bind_dest(struct ip_vs_conn *cp);
1428 
1429 static inline void ip_vs_dest_hold(struct ip_vs_dest *dest)
1430 {
1431         refcount_inc(&dest->refcnt);
1432 }
1433 
1434 static inline void ip_vs_dest_put(struct ip_vs_dest *dest)
1435 {
1436         smp_mb__before_atomic();
1437         refcount_dec(&dest->refcnt);
1438 }
1439 
1440 static inline void ip_vs_dest_put_and_free(struct ip_vs_dest *dest)
1441 {
1442         if (refcount_dec_and_test(&dest->refcnt))
1443                 kfree(dest);
1444 }
1445 
1446 /* IPVS sync daemon data and function prototypes
1447  * (from ip_vs_sync.c)
1448  */
1449 int start_sync_thread(struct netns_ipvs *ipvs, struct ipvs_sync_daemon_cfg *cfg,
1450                       int state);
1451 int stop_sync_thread(struct netns_ipvs *ipvs, int state);
1452 void ip_vs_sync_conn(struct netns_ipvs *ipvs, struct ip_vs_conn *cp, int pkts);
1453 
1454 /* IPVS rate estimator prototypes (from ip_vs_est.c) */
1455 void ip_vs_start_estimator(struct netns_ipvs *ipvs, struct ip_vs_stats *stats);
1456 void ip_vs_stop_estimator(struct netns_ipvs *ipvs, struct ip_vs_stats *stats);
1457 void ip_vs_zero_estimator(struct ip_vs_stats *stats);
1458 void ip_vs_read_estimator(struct ip_vs_kstats *dst, struct ip_vs_stats *stats);
1459 
1460 /* Various IPVS packet transmitters (from ip_vs_xmit.c) */
1461 int ip_vs_null_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
1462                     struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1463 int ip_vs_bypass_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
1464                       struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1465 int ip_vs_nat_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
1466                    struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1467 int ip_vs_tunnel_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
1468                       struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1469 int ip_vs_dr_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
1470                   struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1471 int ip_vs_icmp_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
1472                     struct ip_vs_protocol *pp, int offset,
1473                     unsigned int hooknum, struct ip_vs_iphdr *iph);
1474 void ip_vs_dest_dst_rcu_free(struct rcu_head *head);
1475 
1476 #ifdef CONFIG_IP_VS_IPV6
1477 int ip_vs_bypass_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp,
1478                          struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1479 int ip_vs_nat_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp,
1480                       struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1481 int ip_vs_tunnel_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp,
1482                          struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1483 int ip_vs_dr_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp,
1484                      struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
1485 int ip_vs_icmp_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp,
1486                        struct ip_vs_protocol *pp, int offset,
1487                        unsigned int hooknum, struct ip_vs_iphdr *iph);
1488 #endif
1489 
1490 #ifdef CONFIG_SYSCTL
1491 /* This is a simple mechanism to ignore packets when
1492  * we are loaded. Just set ip_vs_drop_rate to 'n' and
1493  * we start to drop 1/rate of the packets
1494  */
1495 static inline int ip_vs_todrop(struct netns_ipvs *ipvs)
1496 {
1497         if (!ipvs->drop_rate)
1498                 return 0;
1499         if (--ipvs->drop_counter > 0)
1500                 return 0;
1501         ipvs->drop_counter = ipvs->drop_rate;
1502         return 1;
1503 }
1504 #else
1505 static inline int ip_vs_todrop(struct netns_ipvs *ipvs) { return 0; }
1506 #endif
1507 
1508 #define IP_VS_DFWD_METHOD(dest) (atomic_read(&(dest)->conn_flags) & \
1509                                  IP_VS_CONN_F_FWD_MASK)
1510 
1511 /* ip_vs_fwd_tag returns the forwarding tag of the connection */
1512 #define IP_VS_FWD_METHOD(cp)  (cp->flags & IP_VS_CONN_F_FWD_MASK)
1513 
1514 static inline char ip_vs_fwd_tag(struct ip_vs_conn *cp)
1515 {
1516         char fwd;
1517 
1518         switch (IP_VS_FWD_METHOD(cp)) {
1519         case IP_VS_CONN_F_MASQ:
1520                 fwd = 'M'; break;
1521         case IP_VS_CONN_F_LOCALNODE:
1522                 fwd = 'L'; break;
1523         case IP_VS_CONN_F_TUNNEL:
1524                 fwd = 'T'; break;
1525         case IP_VS_CONN_F_DROUTE:
1526                 fwd = 'R'; break;
1527         case IP_VS_CONN_F_BYPASS:
1528                 fwd = 'B'; break;
1529         default:
1530                 fwd = '?'; break;
1531         }
1532         return fwd;
1533 }
1534 
1535 void ip_vs_nat_icmp(struct sk_buff *skb, struct ip_vs_protocol *pp,
1536                     struct ip_vs_conn *cp, int dir);
1537 
1538 #ifdef CONFIG_IP_VS_IPV6
1539 void ip_vs_nat_icmp_v6(struct sk_buff *skb, struct ip_vs_protocol *pp,
1540                        struct ip_vs_conn *cp, int dir);
1541 #endif
1542 
1543 __sum16 ip_vs_checksum_complete(struct sk_buff *skb, int offset);
1544 
1545 static inline __wsum ip_vs_check_diff4(__be32 old, __be32 new, __wsum oldsum)
1546 {
1547         __be32 diff[2] = { ~old, new };
1548 
1549         return csum_partial(diff, sizeof(diff), oldsum);
1550 }
1551 
1552 #ifdef CONFIG_IP_VS_IPV6
1553 static inline __wsum ip_vs_check_diff16(const __be32 *old, const __be32 *new,
1554                                         __wsum oldsum)
1555 {
1556         __be32 diff[8] = { ~old[3], ~old[2], ~old[1], ~old[0],
1557                             new[3],  new[2],  new[1],  new[0] };
1558 
1559         return csum_partial(diff, sizeof(diff), oldsum);
1560 }
1561 #endif
1562 
1563 static inline __wsum ip_vs_check_diff2(__be16 old, __be16 new, __wsum oldsum)
1564 {
1565         __be16 diff[2] = { ~old, new };
1566 
1567         return csum_partial(diff, sizeof(diff), oldsum);
1568 }
1569 
1570 /* Forget current conntrack (unconfirmed) and attach notrack entry */
1571 static inline void ip_vs_notrack(struct sk_buff *skb)
1572 {
1573 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
1574         enum ip_conntrack_info ctinfo;
1575         struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1576 
1577         if (ct) {
1578                 nf_conntrack_put(&ct->ct_general);
1579                 nf_ct_set(skb, NULL, IP_CT_UNTRACKED);
1580         }
1581 #endif
1582 }
1583 
1584 #ifdef CONFIG_IP_VS_NFCT
1585 /* Netfilter connection tracking
1586  * (from ip_vs_nfct.c)
1587  */
1588 static inline int ip_vs_conntrack_enabled(struct netns_ipvs *ipvs)
1589 {
1590 #ifdef CONFIG_SYSCTL
1591         return ipvs->sysctl_conntrack;
1592 #else
1593         return 0;
1594 #endif
1595 }
1596 
1597 void ip_vs_update_conntrack(struct sk_buff *skb, struct ip_vs_conn *cp,
1598                             int outin);
1599 int ip_vs_confirm_conntrack(struct sk_buff *skb);
1600 void ip_vs_nfct_expect_related(struct sk_buff *skb, struct nf_conn *ct,
1601                                struct ip_vs_conn *cp, u_int8_t proto,
1602                                const __be16 port, int from_rs);
1603 void ip_vs_conn_drop_conntrack(struct ip_vs_conn *cp);
1604 
1605 #else
1606 
1607 static inline int ip_vs_conntrack_enabled(struct netns_ipvs *ipvs)
1608 {
1609         return 0;
1610 }
1611 
1612 static inline void ip_vs_update_conntrack(struct sk_buff *skb,
1613                                           struct ip_vs_conn *cp, int outin)
1614 {
1615 }
1616 
1617 static inline int ip_vs_confirm_conntrack(struct sk_buff *skb)
1618 {
1619         return NF_ACCEPT;
1620 }
1621 
1622 static inline void ip_vs_conn_drop_conntrack(struct ip_vs_conn *cp)
1623 {
1624 }
1625 #endif /* CONFIG_IP_VS_NFCT */
1626 
1627 /* Using old conntrack that can not be redirected to another real server? */
1628 static inline bool ip_vs_conn_uses_old_conntrack(struct ip_vs_conn *cp,
1629                                                  struct sk_buff *skb)
1630 {
1631 #ifdef CONFIG_IP_VS_NFCT
1632         enum ip_conntrack_info ctinfo;
1633         struct nf_conn *ct;
1634 
1635         ct = nf_ct_get(skb, &ctinfo);
1636         if (ct && nf_ct_is_confirmed(ct))
1637                 return true;
1638 #endif
1639         return false;
1640 }
1641 
1642 static inline int ip_vs_register_conntrack(struct ip_vs_service *svc)
1643 {
1644 #if IS_ENABLED(CONFIG_NF_CONNTRACK)
1645         int afmask = (svc->af == AF_INET6) ? 2 : 1;
1646         int ret = 0;
1647 
1648         if (!(svc->conntrack_afmask & afmask)) {
1649                 ret = nf_ct_netns_get(svc->ipvs->net, svc->af);
1650                 if (ret >= 0)
1651                         svc->conntrack_afmask |= afmask;
1652         }
1653         return ret;
1654 #else
1655         return 0;
1656 #endif
1657 }
1658 
1659 static inline void ip_vs_unregister_conntrack(struct ip_vs_service *svc)
1660 {
1661 #if IS_ENABLED(CONFIG_NF_CONNTRACK)
1662         int afmask = (svc->af == AF_INET6) ? 2 : 1;
1663 
1664         if (svc->conntrack_afmask & afmask) {
1665                 nf_ct_netns_put(svc->ipvs->net, svc->af);
1666                 svc->conntrack_afmask &= ~afmask;
1667         }
1668 #endif
1669 }
1670 
1671 static inline int
1672 ip_vs_dest_conn_overhead(struct ip_vs_dest *dest)
1673 {
1674         /* We think the overhead of processing active connections is 256
1675          * times higher than that of inactive connections in average. (This
1676          * 256 times might not be accurate, we will change it later) We
1677          * use the following formula to estimate the overhead now:
1678          *                dest->activeconns*256 + dest->inactconns
1679          */
1680         return (atomic_read(&dest->activeconns) << 8) +
1681                 atomic_read(&dest->inactconns);
1682 }
1683 
1684 #endif  /* _NET_IP_VS_H */
1685 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp