Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276/* SPDX-License-Identifier: GPL-2.0 *//* IP Virtual Server * data structure and functionality definitions */
#ifndef _NET_IP_VS_H#define _NET_IP_VS_H
#include <linux/ip_vs.h> /* definitions shared with userland */
#include <asm/types.h> /* for __uXX types */
#include <linux/list.h> /* for struct list_head */#include <linux/rculist_bl.h> /* for struct hlist_bl_head */#include <linux/spinlock.h> /* for struct rwlock_t */#include <linux/atomic.h> /* for struct atomic_t */#include <linux/refcount.h> /* for struct refcount_t */#include <linux/workqueue.h>
#include <linux/compiler.h>#include <linux/timer.h>#include <linux/bug.h>
#include <net/checksum.h>#include <linux/netfilter.h> /* for union nf_inet_addr */#include <linux/ip.h>#include <linux/ipv6.h> /* for struct ipv6hdr */#include <net/ipv6.h>#if IS_ENABLED(CONFIG_NF_CONNTRACK)#include <net/netfilter/nf_conntrack.h>#endif#include <net/net_namespace.h> /* Netw namespace */#include <linux/sched/isolation.h>#include <linux/siphash.h>
#define IP_VS_HDR_INVERSE 1#define IP_VS_HDR_ICMP 2
/* Destination Server Config Flags */#define IP_VS_DEST_CF_AVAILABLE 0x0001 /* server is available */
/* conn_tab limits (as per Kconfig) */#define IP_VS_CONN_TAB_MIN_BITS 8#if BITS_PER_LONG > 32#define IP_VS_CONN_TAB_MAX_BITS 27#else#define IP_VS_CONN_TAB_MAX_BITS 20#endif
/* conn_max limits */#if BITS_PER_LONG > 32/* Limit of atomic_t but restricted by roundup_pow_of_two() in ip_vs_core.c */#define IP_VS_CONN_MAX (1 << 30)#else#define IP_VS_CONN_MAX (1 << 24)#endif
/* svc_table limits */#define IP_VS_SVC_TAB_MIN_BITS 4#define IP_VS_SVC_TAB_MAX_BITS 20
/* Generic access of ipvs struct */static inline struct netns_ipvs *net_ipvs(struct net* net){ return net->ipvs;}
/* Connections' size value needed by ip_vs_ctl.c */extern int ip_vs_conn_tab_size;
struct ip_vs_iphdr { int hdr_flags; /* ipvs flags */ __u32 off; /* Where IP or IPv4 header starts */ __u32 len; /* IPv4 simply where L4 starts * IPv6 where L4 Transport Header starts */ __u16 fragoffs; /* IPv6 fragment offset, 0 if first frag (or not frag)*/ __s16 protocol; __s32 flags; union nf_inet_addr saddr; union nf_inet_addr daddr;};
static inline void *frag_safe_skb_hp(const struct sk_buff *skb, int offset, int len, void *buffer){ return skb_header_pointer(skb, offset, len, buffer);}
/* This function handles filling *ip_vs_iphdr, both for IPv4 and IPv6. * IPv6 requires some extra work, as finding proper header position, * depend on the IPv6 extension headers. */static inline intip_vs_fill_iph_skb_off(int af, const struct sk_buff *skb, int offset, int hdr_flags, struct ip_vs_iphdr *iphdr){ iphdr->hdr_flags = hdr_flags; iphdr->off = offset;
#ifdef CONFIG_IP_VS_IPV6 if (af == AF_INET6) { struct ipv6hdr _iph; const struct ipv6hdr *iph = skb_header_pointer( skb, offset, sizeof(_iph), &_iph); if (!iph) return 0;
iphdr->saddr.in6 = iph->saddr; iphdr->daddr.in6 = iph->daddr; /* ipv6_find_hdr() updates len, flags */ iphdr->len = offset; iphdr->flags = 0; iphdr->protocol = ipv6_find_hdr(skb, &iphdr->len, -1, &iphdr->fragoffs, &iphdr->flags); if (iphdr->protocol < 0) return 0; } else#endif { struct iphdr _iph; const struct iphdr *iph = skb_header_pointer( skb, offset, sizeof(_iph), &_iph); if (!iph) return 0;
iphdr->len = offset + iph->ihl * 4; iphdr->fragoffs = 0; iphdr->protocol = iph->protocol; iphdr->saddr.ip = iph->saddr; iphdr->daddr.ip = iph->daddr; }
return 1;}
static inline intip_vs_fill_iph_skb_icmp(int af, const struct sk_buff *skb, int offset, bool inverse, struct ip_vs_iphdr *iphdr){ int hdr_flags = IP_VS_HDR_ICMP;
if (inverse) hdr_flags |= IP_VS_HDR_INVERSE;
return ip_vs_fill_iph_skb_off(af, skb, offset, hdr_flags, iphdr);}
static inline intip_vs_fill_iph_skb(int af, const struct sk_buff *skb, bool inverse, struct ip_vs_iphdr *iphdr){ int hdr_flags = 0;
if (inverse) hdr_flags |= IP_VS_HDR_INVERSE;
return ip_vs_fill_iph_skb_off(af, skb, skb_network_offset(skb), hdr_flags, iphdr);}
static inline boolip_vs_iph_inverse(const struct ip_vs_iphdr *iph){ return !!(iph->hdr_flags & IP_VS_HDR_INVERSE);}
static inline boolip_vs_iph_icmp(const struct ip_vs_iphdr *iph){ return !!(iph->hdr_flags & IP_VS_HDR_ICMP);}
static inline void ip_vs_addr_copy(int af, union nf_inet_addr *dst, const union nf_inet_addr *src){#ifdef CONFIG_IP_VS_IPV6 if (af == AF_INET6) dst->in6 = src->in6; else#endif dst->ip = src->ip;}
static inline void ip_vs_addr_set(int af, union nf_inet_addr *dst, const union nf_inet_addr *src){#ifdef CONFIG_IP_VS_IPV6 if (af == AF_INET6) { dst->in6 = src->in6; return; }#endif dst->ip = src->ip; dst->all[1] = 0; dst->all[2] = 0; dst->all[3] = 0;}
static inline int ip_vs_addr_equal(int af, const union nf_inet_addr *a, const union nf_inet_addr *b){#ifdef CONFIG_IP_VS_IPV6 if (af == AF_INET6) return ipv6_addr_equal(&a->in6, &b->in6);#endif return a->ip == b->ip;}
#ifdef CONFIG_IP_VS_DEBUG#include <linux/net.h>
int ip_vs_get_debug_level(void);
static inline const char *ip_vs_dbg_addr(int af, char *buf, size_t buf_len, const union nf_inet_addr *addr, int *idx){ int len;#ifdef CONFIG_IP_VS_IPV6 if (af == AF_INET6) len = snprintf(&buf[*idx], buf_len - *idx, "[%pI6c]", &addr->in6) + 1; else#endif len = snprintf(&buf[*idx], buf_len - *idx, "%pI4", &addr->ip) + 1;
*idx += len; BUG_ON(*idx > buf_len + 1); return &buf[*idx - len];}
#define IP_VS_DBG_BUF(level, msg, ...) \ do { \ char ip_vs_dbg_buf[160]; \ int ip_vs_dbg_idx = 0; \ if (level <= ip_vs_get_debug_level()) \ printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__); \ } while (0)#define IP_VS_ERR_BUF(msg...) \ do { \ char ip_vs_dbg_buf[160]; \ int ip_vs_dbg_idx = 0; \ pr_err(msg); \ } while (0)
/* Only use from within IP_VS_DBG_BUF() or IP_VS_ERR_BUF macros */#define IP_VS_DBG_ADDR(af, addr) \ ip_vs_dbg_addr(af, ip_vs_dbg_buf, \ sizeof(ip_vs_dbg_buf), addr, \ &ip_vs_dbg_idx)
#define IP_VS_DBG(level, msg, ...) \ do { \ if (level <= ip_vs_get_debug_level()) \ printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__); \ } while (0)#define IP_VS_DBG_RL(msg, ...) \ do { \ if (net_ratelimit()) \ printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__); \ } while (0)#define IP_VS_DBG_PKT(level, af, pp, skb, ofs, msg) \ do { \ if (level <= ip_vs_get_debug_level()) \ pp->debug_packet(af, pp, skb, ofs, msg); \ } while (0)#define IP_VS_DBG_RL_PKT(level, af, pp, skb, ofs, msg) \ do { \ if (level <= ip_vs_get_debug_level() && \ net_ratelimit()) \ pp->debug_packet(af, pp, skb, ofs, msg); \ } while (0)#else /* NO DEBUGGING at ALL */#define IP_VS_DBG_BUF(level, msg...) do {} while (0)#define IP_VS_ERR_BUF(msg...) do {} while (0)#define IP_VS_DBG(level, msg...) do {} while (0)#define IP_VS_DBG_RL(msg...) do {} while (0)#define IP_VS_DBG_PKT(level, af, pp, skb, ofs, msg) do {} while (0)#define IP_VS_DBG_RL_PKT(level, af, pp, skb, ofs, msg) do {} while (0)#endif
#define IP_VS_BUG() BUG()#define IP_VS_ERR_RL(msg, ...) \ do { \ if (net_ratelimit()) \ pr_err(msg, ##__VA_ARGS__); \ } while (0)
struct ip_vs_aligned_lock { spinlock_t l; /* Protect buckets */} ____cacheline_aligned_in_smp;
/* For arrays per family */enum { IP_VS_AF_INET, IP_VS_AF_INET6, IP_VS_AF_MAX};
static inline int ip_vs_af_index(int af){ return af == AF_INET6 ? IP_VS_AF_INET6 : IP_VS_AF_INET;}
/* work_flags */enum { IP_VS_WORK_SVC_RESIZE, /* Schedule svc_resize_work */ IP_VS_WORK_SVC_NORESIZE, /* Stopping svc_resize_work */ IP_VS_WORK_CONN_RESIZE, /* Schedule conn_resize_work */};
/* The port number of FTP service (in network order). */#define FTPPORT cpu_to_be16(21)#define FTPDATA cpu_to_be16(20)
/* TCP State Values */enum { IP_VS_TCP_S_NONE = 0, IP_VS_TCP_S_ESTABLISHED, IP_VS_TCP_S_SYN_SENT, IP_VS_TCP_S_SYN_RECV, IP_VS_TCP_S_FIN_WAIT, IP_VS_TCP_S_TIME_WAIT, IP_VS_TCP_S_CLOSE, IP_VS_TCP_S_CLOSE_WAIT, IP_VS_TCP_S_LAST_ACK, IP_VS_TCP_S_LISTEN, IP_VS_TCP_S_SYNACK, IP_VS_TCP_S_LAST};
/* UDP State Values */enum { IP_VS_UDP_S_NORMAL, IP_VS_UDP_S_LAST,};
/* ICMP State Values */enum { IP_VS_ICMP_S_NORMAL, IP_VS_ICMP_S_LAST,};
/* SCTP State Values */enum ip_vs_sctp_states { IP_VS_SCTP_S_NONE, IP_VS_SCTP_S_INIT1, IP_VS_SCTP_S_INIT, IP_VS_SCTP_S_COOKIE_SENT, IP_VS_SCTP_S_COOKIE_REPLIED, IP_VS_SCTP_S_COOKIE_WAIT, IP_VS_SCTP_S_COOKIE, IP_VS_SCTP_S_COOKIE_ECHOED, IP_VS_SCTP_S_ESTABLISHED, IP_VS_SCTP_S_SHUTDOWN_SENT, IP_VS_SCTP_S_SHUTDOWN_RECEIVED, IP_VS_SCTP_S_SHUTDOWN_ACK_SENT, IP_VS_SCTP_S_REJECTED, IP_VS_SCTP_S_CLOSED, IP_VS_SCTP_S_LAST};
/* Connection templates use bits from state */#define IP_VS_CTPL_S_NONE 0x0000#define IP_VS_CTPL_S_ASSURED 0x0001#define IP_VS_CTPL_S_LAST 0x0002
/* Delta sequence info structure * Each ip_vs_conn has 2 (output AND input seq. changes). * Only used in the VS/NAT. */struct ip_vs_seq { __u32 init_seq; /* Add delta from this seq */ __u32 delta; /* Delta in sequence numbers */ __u32 previous_delta; /* Delta in sequence numbers * before last resized pkt */};
/* counters per cpu */struct ip_vs_counters { u64_stats_t conns; /* connections scheduled */ u64_stats_t inpkts; /* incoming packets */ u64_stats_t outpkts; /* outgoing packets */ u64_stats_t inbytes; /* incoming bytes */ u64_stats_t outbytes; /* outgoing bytes */};/* Stats per cpu */struct ip_vs_cpu_stats { struct ip_vs_counters cnt; struct u64_stats_sync syncp;};
/* Default nice for estimator kthreads */#define IPVS_EST_NICE 0
/* IPVS statistics objects */struct ip_vs_estimator { struct hlist_node list;
u64 last_inbytes; u64 last_outbytes; u64 last_conns; u64 last_inpkts; u64 last_outpkts;
u64 cps; u64 inpps; u64 outpps; u64 inbps; u64 outbps;
s32 ktid:16, /* kthread ID, -1=temp list */ ktrow:8, /* row/tick ID for kthread */ ktcid:8; /* chain ID for kthread tick */};
/* * IPVS statistics object, 64-bit kernel version of struct ip_vs_stats_user */struct ip_vs_kstats { u64 conns; /* connections scheduled */ u64 inpkts; /* incoming packets */ u64 outpkts; /* outgoing packets */ u64 inbytes; /* incoming bytes */ u64 outbytes; /* outgoing bytes */
u64 cps; /* current connection rate */ u64 inpps; /* current in packet rate */ u64 outpps; /* current out packet rate */ u64 inbps; /* current in byte rate */ u64 outbps; /* current out byte rate */};
struct ip_vs_stats { struct ip_vs_kstats kstats; /* kernel statistics */ struct ip_vs_estimator est; /* estimator */ struct ip_vs_cpu_stats __percpu *cpustats; /* per cpu counters */ spinlock_t lock; /* spin lock */ struct ip_vs_kstats kstats0; /* reset values */};
struct ip_vs_stats_rcu { struct ip_vs_stats s; struct rcu_head rcu_head;};
int ip_vs_stats_init_alloc(struct ip_vs_stats *s);struct ip_vs_stats *ip_vs_stats_alloc(void);void ip_vs_stats_release(struct ip_vs_stats *stats);void ip_vs_stats_free(struct ip_vs_stats *stats);
/* Process estimators in multiple timer ticks (20/50/100, see ktrow) */#define IPVS_EST_NTICKS 50/* Estimation uses a 2-second period containing ticks (in jiffies) */#define IPVS_EST_TICK ((2 * HZ) / IPVS_EST_NTICKS)
/* Limit of CPU load per kthread (8 for 12.5%), ratio of CPU capacity (1/C). * Value of 4 and above ensures kthreads will take work without exceeding * the CPU capacity under different circumstances. */#define IPVS_EST_LOAD_DIVISOR 8
/* Kthreads should not have work that exceeds the CPU load above 50% */#define IPVS_EST_CPU_KTHREADS (IPVS_EST_LOAD_DIVISOR / 2)
/* Desired number of chains per timer tick (chain load factor in 100us units), * 48=4.8ms of 40ms tick (12% CPU usage): * 2 sec * 1000 ms in sec * 10 (100us in ms) / 8 (12.5%) / 50 */#define IPVS_EST_CHAIN_FACTOR \ ALIGN_DOWN(2 * 1000 * 10 / IPVS_EST_LOAD_DIVISOR / IPVS_EST_NTICKS, 8)
/* Compiled number of chains per tick * The defines should match cond_resched_rcu */#if defined(CONFIG_DEBUG_ATOMIC_SLEEP) || !defined(CONFIG_PREEMPT_RCU)#define IPVS_EST_TICK_CHAINS IPVS_EST_CHAIN_FACTOR#else#define IPVS_EST_TICK_CHAINS 1#endif
#if IPVS_EST_NTICKS > 127#error Too many timer ticks for ktrow#endif
/* Multiple chains processed in same tick */struct ip_vs_est_tick_data { struct rcu_head rcu_head; struct hlist_head chains[IPVS_EST_TICK_CHAINS]; DECLARE_BITMAP(present, IPVS_EST_TICK_CHAINS); DECLARE_BITMAP(full, IPVS_EST_TICK_CHAINS); int chain_len[IPVS_EST_TICK_CHAINS];};
/* Context for estimation kthread */struct ip_vs_est_kt_data { struct netns_ipvs *ipvs; struct task_struct *task; /* task if running */ struct ip_vs_est_tick_data __rcu *ticks[IPVS_EST_NTICKS]; DECLARE_BITMAP(avail, IPVS_EST_NTICKS); /* tick has space for ests */ unsigned long est_timer; /* estimation timer (jiffies) */ struct ip_vs_stats *calc_stats; /* Used for calculation */ int needed; /* task is needed */ int tick_len[IPVS_EST_NTICKS]; /* est count */ int id; /* ktid per netns */ int chain_max; /* max ests per tick chain */ int tick_max; /* max ests per tick */ int est_count; /* attached ests to kthread */ int est_max_count; /* max ests per kthread */ int add_row; /* row for new ests */ int est_row; /* estimated row */};
/* IPVS resizable hash tables */struct ip_vs_rht { struct hlist_bl_head *buckets; struct ip_vs_rht __rcu *new_tbl; /* New/Same table */ seqcount_t *seqc; /* Protects moves */ struct ip_vs_aligned_lock *lock; /* Protect seqc */ int mask; /* Buckets mask */ int size; /* Buckets */ int seqc_mask; /* seqc mask */ int lock_mask; /* lock mask */ u32 table_id; int u_thresh; /* upper threshold */ int l_thresh; /* lower threshold */ int lfactor; /* Load Factor (shift)*/ int bits; /* size = 1 << bits */ siphash_key_t hash_key; struct rcu_head rcu_head;};
/** * ip_vs_rht_for_each_table() - Walk the hash tables * @table: struct ip_vs_rht __rcu *table * @t: current table, used as cursor, struct ip_vs_rht *var * @p: previous table, temp struct ip_vs_rht *var * * Walk tables assuming others can not change the installed tables */#define ip_vs_rht_for_each_table(table, t, p) \ for (p = NULL, t = rcu_dereference_protected(table, 1); \ t != p; \ p = t, t = rcu_dereference_protected(t->new_tbl, 1))
/** * ip_vs_rht_for_each_table_rcu() - Walk the hash tables under RCU reader lock * @table: struct ip_vs_rht __rcu *table * @t: current table, used as cursor, struct ip_vs_rht *var * @p: previous table, temp struct ip_vs_rht *var * * We usually search in one table and also in second table on resizing */#define ip_vs_rht_for_each_table_rcu(table, t, p) \ for (p = NULL, t = rcu_dereference(table); \ t != p; \ p = t, t = rcu_dereference(t->new_tbl))
/** * ip_vs_rht_for_each_bucket() - Walk all table buckets * @t: current table, used as cursor, struct ip_vs_rht *var * @bucket: bucket index, used as cursor, u32 var * @head: bucket address, used as cursor, struct hlist_bl_head *var */#define ip_vs_rht_for_each_bucket(t, bucket, head) \ for (bucket = 0, head = (t)->buckets; \ bucket < t->size; bucket++, head++)
/** * ip_vs_rht_for_bucket_retry() - Retry bucket if entries are moved * @t: current table, used as cursor, struct ip_vs_rht *var * @bucket: index of current bucket or hash key * @sc: temp seqcount_t *var * @seq: temp unsigned int var for sequence count * @retry: temp int var */#define ip_vs_rht_for_bucket_retry(t, bucket, sc, seq, retry) \ for (retry = 1, sc = &(t)->seqc[(bucket) & (t)->seqc_mask]; \ retry && ({ seq = read_seqcount_begin(sc); 1; }); \ retry = read_seqcount_retry(sc, seq))
/** * DECLARE_IP_VS_RHT_WALK_BUCKETS_RCU() - Declare variables * * Variables for ip_vs_rht_walk_buckets_rcu */#define DECLARE_IP_VS_RHT_WALK_BUCKETS_RCU() \ struct ip_vs_rht *_t, *_p; \ unsigned int _seq; \ seqcount_t *_sc; \ u32 _bucket; \ int _retry/** * ip_vs_rht_walk_buckets_rcu() - Walk all buckets under RCU read lock * @table: struct ip_vs_rht __rcu *table * @head: bucket address, used as cursor, struct hlist_bl_head *var * * Can be used while others add/delete/move entries * Not suitable if duplicates are not desired * Possible cases for reader that uses cond_resched_rcu() in the loop: * - new table can not be installed, no need to repeat * - new table can be installed => check and repeat if new table is * installed, needed for !PREEMPT_RCU */#define ip_vs_rht_walk_buckets_rcu(table, head) \ ip_vs_rht_for_each_table_rcu(table, _t, _p) \ ip_vs_rht_for_each_bucket(_t, _bucket, head) \ ip_vs_rht_for_bucket_retry(_t, _bucket, _sc, \ _seq, _retry)
/** * DECLARE_IP_VS_RHT_WALK_BUCKET_RCU() - Declare variables * * Variables for ip_vs_rht_walk_bucket_rcu */#define DECLARE_IP_VS_RHT_WALK_BUCKET_RCU() \ unsigned int _seq; \ seqcount_t *_sc; \ int _retry/** * ip_vs_rht_walk_bucket_rcu() - Walk bucket under RCU read lock * @t: current table, struct ip_vs_rht *var * @bucket: index of current bucket or hash key * @head: bucket address, used as cursor, struct hlist_bl_head *var * * Can be used while others add/delete/move entries * Not suitable if duplicates are not desired * Possible cases for reader that uses cond_resched_rcu() in the loop: * - new table can not be installed, no need to repeat * - new table can be installed => check and repeat if new table is * installed, needed for !PREEMPT_RCU */#define ip_vs_rht_walk_bucket_rcu(t, bucket, head) \ if (({ head = (t)->buckets + ((bucket) & (t)->mask); 0; })) \ {} \ else \ ip_vs_rht_for_bucket_retry(t, (bucket), _sc, _seq, _retry)
/** * DECLARE_IP_VS_RHT_WALK_BUCKETS_SAFE_RCU() - Declare variables * * Variables for ip_vs_rht_walk_buckets_safe_rcu */#define DECLARE_IP_VS_RHT_WALK_BUCKETS_SAFE_RCU() \ struct ip_vs_rht *_t, *_p; \ u32 _bucket/** * ip_vs_rht_walk_buckets_safe_rcu() - Walk all buckets under RCU read lock * @table: struct ip_vs_rht __rcu *table * @head: bucket address, used as cursor, struct hlist_bl_head *var * * Can be used while others add/delete entries but moving is disabled * Using cond_resched_rcu() should be safe if tables do not change */#define ip_vs_rht_walk_buckets_safe_rcu(table, head) \ ip_vs_rht_for_each_table_rcu(table, _t, _p) \ ip_vs_rht_for_each_bucket(_t, _bucket, head)
/** * DECLARE_IP_VS_RHT_WALK_BUCKETS() - Declare variables * * Variables for ip_vs_rht_walk_buckets */#define DECLARE_IP_VS_RHT_WALK_BUCKETS() \ struct ip_vs_rht *_t, *_p; \ u32 _bucket
/** * ip_vs_rht_walk_buckets() - Walk all buckets * @table: struct ip_vs_rht __rcu *table * @head: bucket address, used as cursor, struct hlist_bl_head *var * * Use if others can not add/delete/move entries */#define ip_vs_rht_walk_buckets(table, head) \ ip_vs_rht_for_each_table(table, _t, _p) \ ip_vs_rht_for_each_bucket(_t, _bucket, head)
/* Entries can be in one of two tables, so we flip bit when new table is * created and store it as highest bit in hash keys */#define IP_VS_RHT_TABLE_ID_MASK BIT(31)
/* Check if hash key is from this table */static inline bool ip_vs_rht_same_table(struct ip_vs_rht *t, u32 hash_key){ return !((t->table_id ^ hash_key) & IP_VS_RHT_TABLE_ID_MASK);}
/* Build per-table hash key from hash value */static inline u32 ip_vs_rht_build_hash_key(struct ip_vs_rht *t, u32 hash){ return t->table_id | (hash & ~IP_VS_RHT_TABLE_ID_MASK);}
void ip_vs_rht_free(struct ip_vs_rht *t);void ip_vs_rht_rcu_free(struct rcu_head *head);struct ip_vs_rht *ip_vs_rht_alloc(int buckets, int scounts, int locks);int ip_vs_rht_desired_size(struct netns_ipvs *ipvs, struct ip_vs_rht *t, int n, int lfactor, int min_bits, int max_bits);void ip_vs_rht_set_thresholds(struct ip_vs_rht *t, int size, int lfactor, int min_bits, int max_bits);u32 ip_vs_rht_hash_linfo(struct ip_vs_rht *t, int af, const union nf_inet_addr *addr, u32 v1, u32 v2);
struct dst_entry;struct iphdr;struct ip_vs_conn;struct ip_vs_app;struct sk_buff;struct ip_vs_proto_data;
struct ip_vs_protocol { struct ip_vs_protocol *next; char *name; u16 protocol; u16 num_states; int dont_defrag;
void (*init)(struct ip_vs_protocol *pp);
void (*exit)(struct ip_vs_protocol *pp);
int (*init_netns)(struct netns_ipvs *ipvs, struct ip_vs_proto_data *pd);
void (*exit_netns)(struct netns_ipvs *ipvs, struct ip_vs_proto_data *pd);
int (*conn_schedule)(struct netns_ipvs *ipvs, int af, struct sk_buff *skb, struct ip_vs_proto_data *pd, int *verdict, struct ip_vs_conn **cpp, struct ip_vs_iphdr *iph);
struct ip_vs_conn * (*conn_in_get)(struct netns_ipvs *ipvs, int af, const struct sk_buff *skb, const struct ip_vs_iphdr *iph);
struct ip_vs_conn * (*conn_out_get)(struct netns_ipvs *ipvs, int af, const struct sk_buff *skb, const struct ip_vs_iphdr *iph);
int (*snat_handler)(struct sk_buff *skb, struct ip_vs_protocol *pp, struct ip_vs_conn *cp, struct ip_vs_iphdr *iph);
int (*dnat_handler)(struct sk_buff *skb, struct ip_vs_protocol *pp, struct ip_vs_conn *cp, struct ip_vs_iphdr *iph);
const char *(*state_name)(int state);
void (*state_transition)(struct ip_vs_conn *cp, int direction, const struct sk_buff *skb, struct ip_vs_proto_data *pd, unsigned int iph_len);
int (*register_app)(struct netns_ipvs *ipvs, struct ip_vs_app *inc);
void (*unregister_app)(struct netns_ipvs *ipvs, struct ip_vs_app *inc);
int (*app_conn_bind)(struct ip_vs_conn *cp);
void (*debug_packet)(int af, struct ip_vs_protocol *pp, const struct sk_buff *skb, int offset, const char *msg);
void (*timeout_change)(struct ip_vs_proto_data *pd, int flags);};
/* protocol data per netns */struct ip_vs_proto_data { struct ip_vs_proto_data *next; struct ip_vs_protocol *pp; int *timeout_table; /* protocol timeout table */ atomic_t appcnt; /* counter of proto app incs. */ struct tcp_states_t *tcp_state_table;};
struct ip_vs_protocol *ip_vs_proto_get(unsigned short proto);struct ip_vs_proto_data *ip_vs_proto_data_get(struct netns_ipvs *ipvs, unsigned short proto);
struct ip_vs_conn_param { struct netns_ipvs *ipvs; const union nf_inet_addr *caddr; const union nf_inet_addr *vaddr; __be16 cport; __be16 vport; __u16 protocol; u16 af;
const struct ip_vs_pe *pe; char *pe_data; __u8 pe_data_len;};
/* Hash node in conn_tab */struct ip_vs_conn_hnode { struct hlist_bl_node node; /* node in conn_tab */ u32 hash_key; /* Key for the hash table */ u8 dir; /* 0=out->in, 1=in->out */} __packed;
/* IP_VS structure allocated for each dynamically scheduled connection */struct ip_vs_conn { /* Cacheline for hash table nodes - rarely modified */
struct ip_vs_conn_hnode hn0; /* Original direction */ u8 af; /* address family */ __be16 cport; struct ip_vs_conn_hnode hn1; /* Reply direction */ u8 daf; /* Address family of the dest */ __be16 dport; struct ip_vs_dest *dest; /* real server */ atomic_t n_control; /* Number of controlled ones */ volatile __u32 flags; /* status flags */ /* 44/64 */
struct ip_vs_conn *control; /* Master control connection */ const struct ip_vs_pe *pe; char *pe_data; __u8 pe_data_len; volatile __u16 state; /* state info */ volatile __u16 old_state; /* old state, to be used for * state transition triggered * synchronization */ /* 2-byte hole */ /* 64/96 */
union nf_inet_addr caddr; /* client address */ union nf_inet_addr vaddr; /* virtual address */ /* 96/128 */
union nf_inet_addr daddr; /* destination address */ __u32 fwmark; /* Fire wall mark from skb */ __be16 vport; __u16 protocol; /* Which protocol (TCP/UDP) */
/* Note: we can group the following members into a structure, * in order to save more space, and the following members are * only used in VS/NAT anyway */ struct ip_vs_app *app; /* bound ip_vs_app object */ void *app_data; /* Application private data */ /* 128/168 */ struct_group(sync_conn_opt, struct ip_vs_seq in_seq; /* incoming seq. struct */ struct ip_vs_seq out_seq; /* outgoing seq. struct */ ); /* 152/192 */
struct timer_list timer; /* Expiration timer */ volatile unsigned long timeout; /* timeout */ spinlock_t lock; /* lock for state transition */ refcount_t refcnt; /* reference count */ atomic_t in_pkts; /* incoming packet counter */ /* 64-bit: 4-byte gap */
/* 188/256 */ unsigned long sync_endtime; /* jiffies + sent_retries */ struct netns_ipvs *ipvs;
/* Packet transmitter for different forwarding methods. If it * mangles the packet, it must return NF_DROP or better NF_STOLEN, * otherwise this must be changed to a sk_buff **. * NF_ACCEPT can be returned when destination is local. */ int (*packet_xmit)(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);
struct rcu_head rcu_head;};
/* Extended internal versions of struct ip_vs_service_user and ip_vs_dest_user * for IPv6 support. * * We need these to conveniently pass around service and destination * options, but unfortunately, we also need to keep the old definitions to * maintain userspace backwards compatibility for the setsockopt interface. */struct ip_vs_service_user_kern { /* virtual service addresses */ u16 af; u16 protocol; union nf_inet_addr addr; /* virtual ip address */ __be16 port; u32 fwmark; /* firewall mark of service */
/* virtual service options */ char *sched_name; char *pe_name; unsigned int flags; /* virtual service flags */ unsigned int timeout; /* persistent timeout in sec */ __be32 netmask; /* persistent netmask or plen */};
struct ip_vs_dest_user_kern { /* destination server address */ union nf_inet_addr addr; __be16 port;
/* real server options */ unsigned int conn_flags; /* connection flags */ int weight; /* destination weight */
/* thresholds for active connections */ u32 u_threshold; /* upper threshold */ u32 l_threshold; /* lower threshold */
/* Address family of addr */ u16 af;
u16 tun_type; /* tunnel type */ __be16 tun_port; /* tunnel port */ u16 tun_flags; /* tunnel flags */};
/* * The information about the virtual service offered to the net and the * forwarding entries. */struct ip_vs_service { struct hlist_bl_node s_list; /* node in service table */ u32 hash_key; /* Key for the hash table */ u16 af; /* address family */ __u16 protocol; /* which protocol (TCP/UDP) */
union nf_inet_addr addr; /* IP address for virtual service */ __u32 fwmark; /* firewall mark of the service */ atomic_t refcnt; /* reference counter */ __be16 port; /* port number for the service */ unsigned int flags; /* service status flags */ unsigned int timeout; /* persistent timeout in ticks */ __be32 netmask; /* grouping granularity, mask/plen */ struct netns_ipvs *ipvs;
struct list_head destinations; /* real server d-linked list */ __u32 num_dests; /* number of servers */ struct ip_vs_stats stats; /* statistics for the service */
/* for scheduling */ struct ip_vs_scheduler __rcu *scheduler; /* bound scheduler object */ spinlock_t sched_lock; /* lock sched_data */ void *sched_data; /* scheduler application data */
/* alternate persistence engine */ struct ip_vs_pe __rcu *pe; int conntrack_afmask;
struct rcu_head rcu_head;};
/* Information for cached dst */struct ip_vs_dest_dst { struct dst_entry *dst_cache; /* destination cache entry */ u32 dst_cookie; union nf_inet_addr dst_saddr; struct rcu_head rcu_head;};
/* The real server destination forwarding entry with ip address, port number, * and so on. */struct ip_vs_dest { /* Cacheline for hash table nodes - read-mostly */
struct list_head n_list; /* for the dests in the service */ struct hlist_node d_list; /* for table with all the dests */
atomic_t weight; /* server weight */ atomic_t last_weight; /* server latest weight */
/* connection thresholds */ u32 l_threshold_val;/* used lower threshold */ u32 u_threshold_val;/* used upper threshold */ /* 32/48 */ u32 l_threshold; /* lower threshold */ u32 u_threshold; /* upper threshold */
unsigned long cflags; /* config flags */
/* 44/64 */ atomic_t conn_flags; /* flags to copy to conn */
__u16 tun_type; /* tunnel type */ __be16 tun_port; /* tunnel port */ __u16 tun_flags; /* tunnel flags */
u16 af; /* address family */ __be16 port; /* port number of the server */ /* 60/80 */ union nf_inet_addr addr; /* IP address of the server */
/* connection counters */ atomic_t totalconns; /* total connections */ atomic_t activeconns; /* active connections */ atomic_t persistconns; /* persistent connections */
refcount_t refcnt; /* reference counter */ struct ip_vs_stats stats; /* statistics */ unsigned long idle_start; /* start time, jiffies */
/* for destination cache */ spinlock_t dst_lock; /* lock of dst_cache */ struct ip_vs_dest_dst __rcu *dest_dst; /* cached dst info */
/* for virtual service */ struct ip_vs_service __rcu *svc; /* service it belongs to */ __u16 protocol; /* which protocol (TCP/UDP) */ __be16 vport; /* virtual port number */ union nf_inet_addr vaddr; /* virtual IP address */ __u32 vfwmark; /* firewall mark of service */
struct rcu_head rcu_head; struct list_head t_list; /* in dest_trash */ unsigned int in_rs_table:1; /* we are in rs_table */};
/* The scheduler object */struct ip_vs_scheduler { struct list_head n_list; /* d-linked list head */ char *name; /* scheduler name */ atomic_t refcnt; /* reference counter */ struct module *module; /* THIS_MODULE/NULL */
/* scheduler initializing service */ int (*init_service)(struct ip_vs_service *svc); /* scheduling service finish */ void (*done_service)(struct ip_vs_service *svc); /* dest is linked */ int (*add_dest)(struct ip_vs_service *svc, struct ip_vs_dest *dest); /* dest is unlinked */ int (*del_dest)(struct ip_vs_service *svc, struct ip_vs_dest *dest); /* dest is updated */ int (*upd_dest)(struct ip_vs_service *svc, struct ip_vs_dest *dest);
/* selecting a server from the given service */ struct ip_vs_dest* (*schedule)(struct ip_vs_service *svc, const struct sk_buff *skb, struct ip_vs_iphdr *iph);};
/* The persistence engine object */struct ip_vs_pe { struct list_head n_list; /* d-linked list head */ char *name; /* scheduler name */ atomic_t refcnt; /* reference counter */ struct module *module; /* THIS_MODULE/NULL */
/* get the connection template, if any */ int (*fill_param)(struct ip_vs_conn_param *p, struct sk_buff *skb); bool (*ct_match)(const struct ip_vs_conn_param *p, struct ip_vs_conn *ct); u32 (*hashkey_raw)(const struct ip_vs_conn_param *p, struct ip_vs_rht *t, bool inverse); int (*show_pe_data)(const struct ip_vs_conn *cp, char *buf); /* create connections for real-server outgoing packets */ struct ip_vs_conn* (*conn_out)(struct ip_vs_service *svc, struct ip_vs_dest *dest, struct sk_buff *skb, const struct ip_vs_iphdr *iph, __be16 dport, __be16 cport);};
/* The application module object (a.k.a. app incarnation) */struct ip_vs_app { struct list_head a_list; /* member in app list */ int type; /* IP_VS_APP_TYPE_xxx */ char *name; /* application module name */ __u16 protocol; struct module *module; /* THIS_MODULE/NULL */ struct list_head incs_list; /* list of incarnations */
/* members for application incarnations */ struct list_head p_list; /* member in proto app list */ struct ip_vs_app *app; /* its real application */ __be16 port; /* port number in net order */ atomic_t usecnt; /* usage counter */ struct rcu_head rcu_head;
/* output hook: Process packet in inout direction, diff set for TCP. * Return: 0=Error, 1=Payload Not Mangled/Mangled but checksum is ok, * 2=Mangled but checksum was not updated */ int (*pkt_out)(struct ip_vs_app *, struct ip_vs_conn *, struct sk_buff *, int *diff, struct ip_vs_iphdr *ipvsh);
/* input hook: Process packet in outin direction, diff set for TCP. * Return: 0=Error, 1=Payload Not Mangled/Mangled but checksum is ok, * 2=Mangled but checksum was not updated */ int (*pkt_in)(struct ip_vs_app *, struct ip_vs_conn *, struct sk_buff *, int *diff, struct ip_vs_iphdr *ipvsh);
/* ip_vs_app initializer */ int (*init_conn)(struct ip_vs_app *, struct ip_vs_conn *);
/* ip_vs_app finish */ int (*done_conn)(struct ip_vs_app *, struct ip_vs_conn *);
/* not used now */ int (*bind_conn)(struct ip_vs_app *, struct ip_vs_conn *, struct ip_vs_protocol *);
void (*unbind_conn)(struct ip_vs_app *, struct ip_vs_conn *);
int * timeout_table; int * timeouts; int timeouts_size;
int (*conn_schedule)(struct sk_buff *skb, struct ip_vs_app *app, int *verdict, struct ip_vs_conn **cpp);
struct ip_vs_conn * (*conn_in_get)(const struct sk_buff *skb, struct ip_vs_app *app, const struct iphdr *iph, int inverse);
struct ip_vs_conn * (*conn_out_get)(const struct sk_buff *skb, struct ip_vs_app *app, const struct iphdr *iph, int inverse);
int (*state_transition)(struct ip_vs_conn *cp, int direction, const struct sk_buff *skb, struct ip_vs_app *app);
void (*timeout_change)(struct ip_vs_app *app, int flags);};
struct ipvs_master_sync_state { struct list_head sync_queue; struct ip_vs_sync_buff *sync_buff; unsigned long sync_queue_len; unsigned int sync_queue_delay; struct delayed_work master_wakeup_work; struct netns_ipvs *ipvs;};
struct ip_vs_sync_thread_data;
/* How much time to keep dests in trash */#define IP_VS_DEST_TRASH_PERIOD (120 * HZ)
struct ipvs_sync_daemon_cfg { union nf_inet_addr mcast_group; int syncid; u16 sync_maxlen; u16 mcast_port; u8 mcast_af; u8 mcast_ttl; /* multicast interface name */ char mcast_ifn[IP_VS_IFNAME_MAXLEN];};
/* IPVS in network namespace */struct netns_ipvs { int gen; /* Generation */ int enable; /* enable like nf_hooks do */ /* Hash table: for real service lookups */ #define IP_VS_RTAB_BITS 4 #define IP_VS_RTAB_SIZE (1 << IP_VS_RTAB_BITS) #define IP_VS_RTAB_MASK (IP_VS_RTAB_SIZE - 1)
struct hlist_head rs_table[IP_VS_RTAB_SIZE]; /* ip_vs_app */ struct list_head app_list; /* ip_vs_proto */ #define IP_VS_PROTO_TAB_SIZE 32 /* must be power of 2 */ struct ip_vs_proto_data *proto_data_table[IP_VS_PROTO_TAB_SIZE]; /* ip_vs_proto_tcp */#ifdef CONFIG_IP_VS_PROTO_TCP #define TCP_APP_TAB_BITS 4 #define TCP_APP_TAB_SIZE (1 << TCP_APP_TAB_BITS) #define TCP_APP_TAB_MASK (TCP_APP_TAB_SIZE - 1) struct list_head tcp_apps[TCP_APP_TAB_SIZE];#endif /* ip_vs_proto_udp */#ifdef CONFIG_IP_VS_PROTO_UDP #define UDP_APP_TAB_BITS 4 #define UDP_APP_TAB_SIZE (1 << UDP_APP_TAB_BITS) #define UDP_APP_TAB_MASK (UDP_APP_TAB_SIZE - 1) struct list_head udp_apps[UDP_APP_TAB_SIZE];#endif /* ip_vs_proto_sctp */#ifdef CONFIG_IP_VS_PROTO_SCTP #define SCTP_APP_TAB_BITS 4 #define SCTP_APP_TAB_SIZE (1 << SCTP_APP_TAB_BITS) #define SCTP_APP_TAB_MASK (SCTP_APP_TAB_SIZE - 1) /* Hash table for SCTP application incarnations */ struct list_head sctp_apps[SCTP_APP_TAB_SIZE];#endif /* ip_vs_conn */ atomic_t conn_count; /* connection counter */ atomic_t no_cport_conns[IP_VS_AF_MAX]; struct delayed_work conn_resize_work;/* resize conn_tab */
/* ip_vs_ctl */ struct ip_vs_stats_rcu *tot_stats; /* Statistics & est. */
/* Trash for destinations */ struct list_head dest_trash; spinlock_t dest_trash_lock; struct timer_list dest_trash_timer; /* expiration timer */ struct mutex service_mutex; /* service reconfig */ struct rw_semaphore svc_resize_sem; /* svc_table resizing */ struct rw_semaphore svc_replace_sem; /* svc_table replace */ struct delayed_work svc_resize_work; /* resize svc_table */ atomic_t svc_table_changes;/* ++ on table changes */ /* Service counters */ atomic_t num_services[IP_VS_AF_MAX]; /* Services */ atomic_t fwm_services[IP_VS_AF_MAX]; /* Services */ atomic_t nonfwm_services[IP_VS_AF_MAX];/* Services */ atomic_t ftpsvc_counter[IP_VS_AF_MAX]; /* FTPPORT */ atomic_t nullsvc_counter[IP_VS_AF_MAX];/* Zero port */ atomic_t conn_out_counter[IP_VS_AF_MAX];/* out conn */
#ifdef CONFIG_SYSCTL /* delayed work for expiring no dest connections */ struct delayed_work expire_nodest_conn_work; /* 1/rate drop and drop-entry variables */ struct delayed_work defense_work; /* Work handler */ int drop_rate; int drop_counter; int old_secure_tcp; atomic_t dropentry; s8 dropentry_counters[8]; /* locks in ctl.c */ spinlock_t dropentry_lock; /* drop entry handling */ spinlock_t droppacket_lock; /* drop packet handling */ spinlock_t securetcp_lock; /* state and timeout tables */
/* sys-ctl struct */ struct ctl_table_header *sysctl_hdr; struct ctl_table *sysctl_tbl;#endif
/* sysctl variables */ int sysctl_amemthresh; int sysctl_am_droprate;#ifdef CONFIG_SYSCTL int sysctl_conn_max;/* soft limit for conns */ int conn_max_limit; /* hard limit for conn_max */#endif int sysctl_drop_entry; int sysctl_drop_packet; int sysctl_secure_tcp;#ifdef CONFIG_IP_VS_NFCT int sysctl_conntrack;#endif int sysctl_snat_reroute; int sysctl_sync_ver; int sysctl_sync_ports; int sysctl_sync_persist_mode; unsigned long sysctl_sync_qlen_max; int sysctl_sync_sock_size; int sysctl_cache_bypass; int sysctl_expire_nodest_conn; int sysctl_sloppy_tcp; int sysctl_sloppy_sctp; int sysctl_expire_quiescent_template; int sysctl_sync_threshold[2]; unsigned int sysctl_sync_refresh_period; int sysctl_sync_retries; int sysctl_nat_icmp_send; int sysctl_pmtu_disc; int sysctl_backup_only; int sysctl_conn_reuse_mode; int sysctl_schedule_icmp; int sysctl_ignore_tunneled; int sysctl_run_estimation;#ifdef CONFIG_SYSCTL cpumask_var_t sysctl_est_cpulist; /* kthread cpumask */ int est_cpulist_valid; /* cpulist set */ int sysctl_est_nice; /* kthread nice */ int est_stopped; /* stop tasks */#endif int sysctl_conn_lfactor; int sysctl_svc_lfactor;
/* ip_vs_lblc */ int sysctl_lblc_expiration; struct ctl_table_header *lblc_ctl_header; struct ctl_table *lblc_ctl_table; /* ip_vs_lblcr */ int sysctl_lblcr_expiration; struct ctl_table_header *lblcr_ctl_header; struct ctl_table *lblcr_ctl_table; unsigned long work_flags; /* IP_VS_WORK_* flags */ /* ip_vs_est */ struct delayed_work est_reload_work;/* Reload kthread tasks */ struct mutex est_mutex; /* protect kthread tasks */ struct hlist_head est_temp_list; /* Ests during calc phase */ struct ip_vs_est_kt_data **est_kt_arr; /* Array of kthread data ptrs */ unsigned long est_max_threads;/* Hard limit of kthreads */ int est_calc_phase; /* Calculation phase */ int est_chain_max; /* Calculated chain_max */ int est_kt_count; /* Allocated ptrs */ int est_add_ktid; /* ktid where to add ests */ atomic_t est_genid; /* kthreads reload genid */ atomic_t est_genid_done; /* applied genid */ /* ip_vs_sync */ spinlock_t sync_lock; struct ipvs_master_sync_state *ms; spinlock_t sync_buff_lock; struct ip_vs_sync_thread_data *master_tinfo; struct ip_vs_sync_thread_data *backup_tinfo; int threads_mask; volatile int sync_state; struct mutex sync_mutex; struct ipvs_sync_daemon_cfg mcfg; /* Master Configuration */ struct ipvs_sync_daemon_cfg bcfg; /* Backup Configuration */ /* net name space ptr */ struct net *net; /* Needed by timer routines */ /* Number of heterogeneous destinations, needed because heterogeneous * are not supported when synchronization is enabled. */ unsigned int mixed_address_family_dests; unsigned int hooks_afmask; /* &1=AF_INET, &2=AF_INET6 */
struct ip_vs_rht __rcu *svc_table; /* Services */ struct ip_vs_rht __rcu *conn_tab; /* Connections */ atomic_t conn_tab_changes;/* ++ on new table */};
#define DEFAULT_SYNC_THRESHOLD 3#define DEFAULT_SYNC_PERIOD 50#define DEFAULT_SYNC_VER 1#define DEFAULT_SLOPPY_TCP 0#define DEFAULT_SLOPPY_SCTP 0#define DEFAULT_SYNC_REFRESH_PERIOD (0U * HZ)#define DEFAULT_SYNC_RETRIES 0#define IPVS_SYNC_WAKEUP_RATE 8#define IPVS_SYNC_QLEN_MAX (IPVS_SYNC_WAKEUP_RATE * 4)#define IPVS_SYNC_SEND_DELAY (HZ / 50)#define IPVS_SYNC_CHECK_PERIOD HZ#define IPVS_SYNC_FLUSH_TIME (HZ * 2)#define IPVS_SYNC_PORTS_MAX (1 << 6)
#ifdef CONFIG_SYSCTL
static inline int sysctl_conn_max(struct netns_ipvs *ipvs){ return READ_ONCE(ipvs->sysctl_conn_max);}
static inline int sysctl_sync_threshold(struct netns_ipvs *ipvs){ return ipvs->sysctl_sync_threshold[0];}
static inline int sysctl_sync_period(struct netns_ipvs *ipvs){ return READ_ONCE(ipvs->sysctl_sync_threshold[1]);}
static inline unsigned int sysctl_sync_refresh_period(struct netns_ipvs *ipvs){ return READ_ONCE(ipvs->sysctl_sync_refresh_period);}
static inline int sysctl_sync_retries(struct netns_ipvs *ipvs){ return ipvs->sysctl_sync_retries;}
static inline int sysctl_sync_ver(struct netns_ipvs *ipvs){ return ipvs->sysctl_sync_ver;}
static inline int sysctl_sloppy_tcp(struct netns_ipvs *ipvs){ return ipvs->sysctl_sloppy_tcp;}
static inline int sysctl_sloppy_sctp(struct netns_ipvs *ipvs){ return ipvs->sysctl_sloppy_sctp;}
static inline int sysctl_sync_ports(struct netns_ipvs *ipvs){ return READ_ONCE(ipvs->sysctl_sync_ports);}
static inline int sysctl_sync_persist_mode(struct netns_ipvs *ipvs){ return ipvs->sysctl_sync_persist_mode;}
static inline unsigned long sysctl_sync_qlen_max(struct netns_ipvs *ipvs){ return ipvs->sysctl_sync_qlen_max;}
static inline int sysctl_sync_sock_size(struct netns_ipvs *ipvs){ return ipvs->sysctl_sync_sock_size;}
static inline int sysctl_pmtu_disc(struct netns_ipvs *ipvs){ return ipvs->sysctl_pmtu_disc;}
static inline int sysctl_backup_only(struct netns_ipvs *ipvs){ return ipvs->sync_state & IP_VS_STATE_BACKUP && ipvs->sysctl_backup_only;}
static inline int sysctl_conn_reuse_mode(struct netns_ipvs *ipvs){ return ipvs->sysctl_conn_reuse_mode;}
static inline int sysctl_expire_nodest_conn(struct netns_ipvs *ipvs){ return ipvs->sysctl_expire_nodest_conn;}
static inline int sysctl_schedule_icmp(struct netns_ipvs *ipvs){ return ipvs->sysctl_schedule_icmp;}
static inline int sysctl_ignore_tunneled(struct netns_ipvs *ipvs){ return ipvs->sysctl_ignore_tunneled;}
static inline int sysctl_cache_bypass(struct netns_ipvs *ipvs){ return ipvs->sysctl_cache_bypass;}
static inline int sysctl_run_estimation(struct netns_ipvs *ipvs){ return ipvs->sysctl_run_estimation;}
static inline const struct cpumask *__sysctl_est_cpulist(struct netns_ipvs *ipvs){ if (ipvs->est_cpulist_valid) return ipvs->sysctl_est_cpulist; else return housekeeping_cpumask(HK_TYPE_KTHREAD);}
static inline const struct cpumask *sysctl_est_preferred_cpulist(struct netns_ipvs *ipvs){ if (ipvs->est_cpulist_valid) return ipvs->sysctl_est_cpulist; else return NULL;}
static inline int sysctl_est_nice(struct netns_ipvs *ipvs){ return ipvs->sysctl_est_nice;}
#else
static inline int sysctl_conn_max(struct netns_ipvs *ipvs){ return IP_VS_CONN_MAX;}
static inline int sysctl_sync_threshold(struct netns_ipvs *ipvs){ return DEFAULT_SYNC_THRESHOLD;}
static inline int sysctl_sync_period(struct netns_ipvs *ipvs){ return DEFAULT_SYNC_PERIOD;}
static inline unsigned int sysctl_sync_refresh_period(struct netns_ipvs *ipvs){ return DEFAULT_SYNC_REFRESH_PERIOD;}
static inline int sysctl_sync_retries(struct netns_ipvs *ipvs){ return DEFAULT_SYNC_RETRIES & 3;}
static inline int sysctl_sync_ver(struct netns_ipvs *ipvs){ return DEFAULT_SYNC_VER;}
static inline int sysctl_sloppy_tcp(struct netns_ipvs *ipvs){ return DEFAULT_SLOPPY_TCP;}
static inline int sysctl_sloppy_sctp(struct netns_ipvs *ipvs){ return DEFAULT_SLOPPY_SCTP;}
static inline int sysctl_sync_ports(struct netns_ipvs *ipvs){ return 1;}
static inline int sysctl_sync_persist_mode(struct netns_ipvs *ipvs){ return 0;}
static inline unsigned long sysctl_sync_qlen_max(struct netns_ipvs *ipvs){ return IPVS_SYNC_QLEN_MAX;}
static inline int sysctl_sync_sock_size(struct netns_ipvs *ipvs){ return 0;}
static inline int sysctl_pmtu_disc(struct netns_ipvs *ipvs){ return 1;}
static inline int sysctl_backup_only(struct netns_ipvs *ipvs){ return 0;}
static inline int sysctl_conn_reuse_mode(struct netns_ipvs *ipvs){ return 1;}
static inline int sysctl_expire_nodest_conn(struct netns_ipvs *ipvs){ return 0;}
static inline int sysctl_schedule_icmp(struct netns_ipvs *ipvs){ return 0;}
static inline int sysctl_ignore_tunneled(struct netns_ipvs *ipvs){ return 0;}
static inline int sysctl_cache_bypass(struct netns_ipvs *ipvs){ return 0;}
static inline int sysctl_run_estimation(struct netns_ipvs *ipvs){ return 1;}
static inline const struct cpumask *__sysctl_est_cpulist(struct netns_ipvs *ipvs){ return housekeeping_cpumask(HK_TYPE_KTHREAD);}
static inline const struct cpumask *sysctl_est_preferred_cpulist(struct netns_ipvs *ipvs){ return NULL;}
static inline int sysctl_est_nice(struct netns_ipvs *ipvs){ return IPVS_EST_NICE;}
#endif
/* Get load factor to map conn_count/u_thresh to t->size */static inline int sysctl_conn_lfactor(struct netns_ipvs *ipvs){ return READ_ONCE(ipvs->sysctl_conn_lfactor);}
/* Get load factor to map num_services/u_thresh to t->size * Smaller value decreases u_thresh to reduce collisions but increases * the table size * Returns factor where: * - <0: u_thresh = size >> -factor, eg. lfactor -2 = 25% load * - >=0: u_thresh = size << factor, eg. lfactor 1 = 200% load */static inline int sysctl_svc_lfactor(struct netns_ipvs *ipvs){ return READ_ONCE(ipvs->sysctl_svc_lfactor);}
static inline bool sysctl_est_cpulist_empty(struct netns_ipvs *ipvs){ guard(rcu)(); return cpumask_empty(__sysctl_est_cpulist(ipvs));}
static inline unsigned int sysctl_est_cpulist_weight(struct netns_ipvs *ipvs){ guard(rcu)(); return cpumask_weight(__sysctl_est_cpulist(ipvs));}
/* IPVS core functions * (from ip_vs_core.c) */const char *ip_vs_proto_name(unsigned int proto);void ip_vs_init_hash_table(struct list_head *table, int rows);struct ip_vs_conn *ip_vs_new_conn_out(struct ip_vs_service *svc, struct ip_vs_dest *dest, struct sk_buff *skb, const struct ip_vs_iphdr *iph, __be16 dport, __be16 cport);#define IP_VS_INIT_HASH_TABLE(t) ip_vs_init_hash_table((t), ARRAY_SIZE((t)))
#define IP_VS_APP_TYPE_FTP 1
/* ip_vs_conn handling functions * (from ip_vs_conn.c) */enum { IP_VS_DIR_INPUT = 0, IP_VS_DIR_OUTPUT, IP_VS_DIR_INPUT_ONLY, IP_VS_DIR_LAST,};
static inline void ip_vs_conn_fill_param(struct netns_ipvs *ipvs, int af, int protocol, const union nf_inet_addr *caddr, __be16 cport, const union nf_inet_addr *vaddr, __be16 vport, struct ip_vs_conn_param *p){ p->ipvs = ipvs; p->af = af; p->protocol = protocol; p->caddr = caddr; p->cport = cport; p->vaddr = vaddr; p->vport = vport; p->pe = NULL; p->pe_data = NULL;}
struct ip_vs_conn *ip_vs_conn_in_get(const struct ip_vs_conn_param *p);struct ip_vs_conn *ip_vs_ct_in_get(const struct ip_vs_conn_param *p);
struct ip_vs_conn * ip_vs_conn_in_get_proto(struct netns_ipvs *ipvs, int af, const struct sk_buff *skb, const struct ip_vs_iphdr *iph);
struct ip_vs_conn *ip_vs_conn_out_get(const struct ip_vs_conn_param *p);
struct ip_vs_conn * ip_vs_conn_out_get_proto(struct netns_ipvs *ipvs, int af, const struct sk_buff *skb, const struct ip_vs_iphdr *iph);
/* Get reference to gain full access to conn. * By default, RCU read-side critical sections have access only to * conn fields and its PE data, see ip_vs_conn_rcu_free() for reference. */static inline bool __ip_vs_conn_get(struct ip_vs_conn *cp){ return refcount_inc_not_zero(&cp->refcnt);}
/* put back the conn without restarting its timer */static inline void __ip_vs_conn_put(struct ip_vs_conn *cp){ smp_mb__before_atomic(); refcount_dec(&cp->refcnt);}void ip_vs_conn_put(struct ip_vs_conn *cp);void ip_vs_conn_fill_cport(struct ip_vs_conn *cp, __be16 cport);int ip_vs_conn_desired_size(struct netns_ipvs *ipvs, struct ip_vs_rht *t, int lfactor);struct ip_vs_rht *ip_vs_conn_tab_alloc(struct netns_ipvs *ipvs, int buckets, int lfactor);
static inline struct ip_vs_conn *ip_vs_hn0_to_conn(struct ip_vs_conn_hnode *hn){ return container_of(hn, struct ip_vs_conn, hn0);}
static inline struct ip_vs_conn *ip_vs_hn_to_conn(struct ip_vs_conn_hnode *hn){ return hn->dir ? container_of(hn, struct ip_vs_conn, hn1) : container_of(hn, struct ip_vs_conn, hn0);}
struct ip_vs_conn *ip_vs_conn_new(const struct ip_vs_conn_param *p, int dest_af, const union nf_inet_addr *daddr, __be16 dport, unsigned int flags, struct ip_vs_dest *dest, __u32 fwmark);void ip_vs_conn_expire_now(struct ip_vs_conn *cp);
const char *ip_vs_state_name(const struct ip_vs_conn *cp);
void ip_vs_tcp_conn_listen(struct ip_vs_conn *cp);int ip_vs_check_template(struct ip_vs_conn *ct, struct ip_vs_dest *cdest);void ip_vs_random_dropentry(struct netns_ipvs *ipvs);int ip_vs_conn_init(void);void ip_vs_conn_cleanup(void);
static inline void ip_vs_control_del(struct ip_vs_conn *cp){ struct ip_vs_conn *ctl_cp = cp->control; if (!ctl_cp) { IP_VS_ERR_BUF("request control DEL for uncontrolled: " "%s:%d to %s:%d\n", IP_VS_DBG_ADDR(cp->af, &cp->caddr), ntohs(cp->cport), IP_VS_DBG_ADDR(cp->af, &cp->vaddr), ntohs(cp->vport));
return; }
IP_VS_DBG_BUF(7, "DELeting control for: " "cp.dst=%s:%d ctl_cp.dst=%s:%d\n", IP_VS_DBG_ADDR(cp->af, &cp->caddr), ntohs(cp->cport), IP_VS_DBG_ADDR(cp->af, &ctl_cp->caddr), ntohs(ctl_cp->cport));
cp->control = NULL; if (atomic_read(&ctl_cp->n_control) == 0) { IP_VS_ERR_BUF("BUG control DEL with n=0 : " "%s:%d to %s:%d\n", IP_VS_DBG_ADDR(cp->af, &cp->caddr), ntohs(cp->cport), IP_VS_DBG_ADDR(cp->af, &cp->vaddr), ntohs(cp->vport));
return; } atomic_dec(&ctl_cp->n_control);}
static inline voidip_vs_control_add(struct ip_vs_conn *cp, struct ip_vs_conn *ctl_cp){ if (cp->control) { IP_VS_ERR_BUF("request control ADD for already controlled: " "%s:%d to %s:%d\n", IP_VS_DBG_ADDR(cp->af, &cp->caddr), ntohs(cp->cport), IP_VS_DBG_ADDR(cp->af, &cp->vaddr), ntohs(cp->vport));
ip_vs_control_del(cp); }
IP_VS_DBG_BUF(7, "ADDing control for: " "cp.dst=%s:%d ctl_cp.dst=%s:%d\n", IP_VS_DBG_ADDR(cp->af, &cp->caddr), ntohs(cp->cport), IP_VS_DBG_ADDR(cp->af, &ctl_cp->caddr), ntohs(ctl_cp->cport));
cp->control = ctl_cp; atomic_inc(&ctl_cp->n_control);}
/* Mark our template as assured */static inline voidip_vs_control_assure_ct(struct ip_vs_conn *cp){ struct ip_vs_conn *ct = cp->control;
if (ct && !(ct->state & IP_VS_CTPL_S_ASSURED) && (ct->flags & IP_VS_CONN_F_TEMPLATE)) ct->state |= IP_VS_CTPL_S_ASSURED;}
/* IPVS netns init & cleanup functions */int ip_vs_estimator_net_init(struct netns_ipvs *ipvs);int ip_vs_control_net_init(struct netns_ipvs *ipvs);int ip_vs_protocol_net_init(struct netns_ipvs *ipvs);int ip_vs_app_net_init(struct netns_ipvs *ipvs);int ip_vs_conn_net_init(struct netns_ipvs *ipvs);int ip_vs_sync_net_init(struct netns_ipvs *ipvs);void ip_vs_conn_net_cleanup(struct netns_ipvs *ipvs);void ip_vs_app_net_cleanup(struct netns_ipvs *ipvs);void ip_vs_protocol_net_cleanup(struct netns_ipvs *ipvs);void ip_vs_control_net_cleanup(struct netns_ipvs *ipvs);void ip_vs_estimator_net_cleanup(struct netns_ipvs *ipvs);void ip_vs_sync_net_cleanup(struct netns_ipvs *ipvs);void ip_vs_service_nets_cleanup(struct list_head *net_list);
/* IPVS application functions * (from ip_vs_app.c) */#define IP_VS_APP_MAX_PORTS 8struct ip_vs_app *register_ip_vs_app(struct netns_ipvs *ipvs, struct ip_vs_app *app);void unregister_ip_vs_app(struct netns_ipvs *ipvs, struct ip_vs_app *app);int ip_vs_bind_app(struct ip_vs_conn *cp, struct ip_vs_protocol *pp);void ip_vs_unbind_app(struct ip_vs_conn *cp);int register_ip_vs_app_inc(struct netns_ipvs *ipvs, struct ip_vs_app *app, __u16 proto, __u16 port);int ip_vs_app_inc_get(struct ip_vs_app *inc);void ip_vs_app_inc_put(struct ip_vs_app *inc);
int ip_vs_app_pkt_out(struct ip_vs_conn *, struct sk_buff *skb, struct ip_vs_iphdr *ipvsh);int ip_vs_app_pkt_in(struct ip_vs_conn *, struct sk_buff *skb, struct ip_vs_iphdr *ipvsh);
int register_ip_vs_pe(struct ip_vs_pe *pe);int unregister_ip_vs_pe(struct ip_vs_pe *pe);struct ip_vs_pe *ip_vs_pe_getbyname(const char *name);struct ip_vs_pe *__ip_vs_pe_getbyname(const char *pe_name);
/* Use a #define to avoid all of module.h just for these trivial ops */#define ip_vs_pe_get(pe) \ if (pe && pe->module) \ __module_get(pe->module);
#define ip_vs_pe_put(pe) \ if (pe && pe->module) \ module_put(pe->module);
/* IPVS protocol functions (from ip_vs_proto.c) */int ip_vs_protocol_init(void);void ip_vs_protocol_cleanup(void);void ip_vs_protocol_timeout_change(struct netns_ipvs *ipvs, int flags);int *ip_vs_create_timeout_table(int *table, int size);void ip_vs_tcpudp_debug_packet(int af, struct ip_vs_protocol *pp, const struct sk_buff *skb, int offset, const char *msg);
extern struct ip_vs_protocol ip_vs_protocol_tcp;extern struct ip_vs_protocol ip_vs_protocol_udp;extern struct ip_vs_protocol ip_vs_protocol_icmp;extern struct ip_vs_protocol ip_vs_protocol_esp;extern struct ip_vs_protocol ip_vs_protocol_ah;extern struct ip_vs_protocol ip_vs_protocol_sctp;
/* Registering/unregistering scheduler functions * (from ip_vs_sched.c) */int register_ip_vs_scheduler(struct ip_vs_scheduler *scheduler);int unregister_ip_vs_scheduler(struct ip_vs_scheduler *scheduler);int ip_vs_bind_scheduler(struct ip_vs_service *svc, struct ip_vs_scheduler *scheduler);void ip_vs_unbind_scheduler(struct ip_vs_service *svc);struct ip_vs_scheduler *ip_vs_scheduler_get(const char *sched_name);void ip_vs_scheduler_put(struct ip_vs_scheduler *scheduler);struct ip_vs_conn *ip_vs_schedule(struct ip_vs_service *svc, struct sk_buff *skb, struct ip_vs_proto_data *pd, int *ignored, struct ip_vs_iphdr *iph);int ip_vs_leave(struct ip_vs_service *svc, struct sk_buff *skb, struct ip_vs_proto_data *pd, struct ip_vs_iphdr *iph);
void ip_vs_scheduler_err(struct ip_vs_service *svc, const char *msg);
/* IPVS control data and functions (from ip_vs_ctl.c) */extern struct ip_vs_stats ip_vs_stats;extern int sysctl_ip_vs_sync_ver;
struct ip_vs_service *ip_vs_service_find(struct netns_ipvs *ipvs, int af, __u32 fwmark, __u16 protocol, const union nf_inet_addr *vaddr, __be16 vport);
bool ip_vs_has_real_service(struct netns_ipvs *ipvs, int af, __u16 protocol, const union nf_inet_addr *daddr, __be16 dport);
struct ip_vs_dest *ip_vs_find_real_service(struct netns_ipvs *ipvs, int af, __u16 protocol, const union nf_inet_addr *daddr, __be16 dport);struct ip_vs_dest *ip_vs_find_tunnel(struct netns_ipvs *ipvs, int af, const union nf_inet_addr *daddr, __be16 tun_port);
int ip_vs_use_count_inc(void);void ip_vs_use_count_dec(void);int ip_vs_register_nl_ioctl(void);void ip_vs_unregister_nl_ioctl(void);int ip_vs_control_init(void);void ip_vs_control_cleanup(void);struct ip_vs_dest *ip_vs_find_dest(struct netns_ipvs *ipvs, int svc_af, int dest_af, const union nf_inet_addr *daddr, __be16 dport, const union nf_inet_addr *vaddr, __be16 vport, __u16 protocol, __u32 fwmark, __u32 flags);void ip_vs_try_bind_dest(struct ip_vs_conn *cp);
static inline void ip_vs_dest_hold(struct ip_vs_dest *dest){ refcount_inc(&dest->refcnt);}
static inline void ip_vs_dest_put(struct ip_vs_dest *dest){ smp_mb__before_atomic(); refcount_dec(&dest->refcnt);}
static inline void ip_vs_dest_put_and_free(struct ip_vs_dest *dest){ if (refcount_dec_and_test(&dest->refcnt)) kfree(dest);}
void ip_vs_dest_update_overload(struct ip_vs_dest *dest, bool overload);
/* Check if dest is in overloaded state */static inline bool ip_vs_dest_is_overloaded(const struct ip_vs_dest *dest){ return READ_ONCE(dest->l_threshold_val);}
/* IPVS sync daemon data and function prototypes * (from ip_vs_sync.c) */int start_sync_thread(struct netns_ipvs *ipvs, struct ipvs_sync_daemon_cfg *cfg, int state);int stop_sync_thread(struct netns_ipvs *ipvs, int state);void ip_vs_sync_conn(struct netns_ipvs *ipvs, struct ip_vs_conn *cp, int pkts);
/* IPVS rate estimator prototypes (from ip_vs_est.c) */int ip_vs_start_estimator(struct netns_ipvs *ipvs, struct ip_vs_stats *stats);void ip_vs_stop_estimator(struct netns_ipvs *ipvs, struct ip_vs_stats *stats);void ip_vs_zero_estimator(struct ip_vs_stats *stats);void ip_vs_read_estimator(struct ip_vs_kstats *dst, struct ip_vs_stats *stats);void ip_vs_est_reload_start(struct netns_ipvs *ipvs, bool restart);int ip_vs_est_kthread_start(struct netns_ipvs *ipvs, struct ip_vs_est_kt_data *kd);void ip_vs_est_kthread_stop(struct ip_vs_est_kt_data *kd);
static inline void ip_vs_stop_estimator_tot_stats(struct netns_ipvs *ipvs){#ifdef CONFIG_SYSCTL ip_vs_stop_estimator(ipvs, &ipvs->tot_stats->s); ipvs->tot_stats->s.est.ktid = -2;#endif}
static inline void ip_vs_est_stopped_recalc(struct netns_ipvs *ipvs){#ifdef CONFIG_SYSCTL /* Stop tasks while cpulist is empty or if disabled with flag */ ipvs->est_stopped = !sysctl_run_estimation(ipvs) || (ipvs->est_cpulist_valid && sysctl_est_cpulist_empty(ipvs));#endif}
static inline bool ip_vs_est_stopped(struct netns_ipvs *ipvs){#ifdef CONFIG_SYSCTL return ipvs->est_stopped;#else return false;#endif}
static inline int ip_vs_est_max_threads(struct netns_ipvs *ipvs){ unsigned int limit = IPVS_EST_CPU_KTHREADS * sysctl_est_cpulist_weight(ipvs);
return max(1U, limit);}
/* Various IPVS packet transmitters (from ip_vs_xmit.c) */int ip_vs_null_xmit(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);int ip_vs_bypass_xmit(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);int ip_vs_nat_xmit(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);int ip_vs_tunnel_xmit(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);int ip_vs_dr_xmit(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);int ip_vs_icmp_xmit(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, unsigned int toff, unsigned int hooknum, struct ip_vs_iphdr *ciph);void ip_vs_dest_dst_rcu_free(struct rcu_head *head);
#ifdef CONFIG_IP_VS_IPV6int ip_vs_bypass_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);int ip_vs_nat_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);int ip_vs_tunnel_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);int ip_vs_dr_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, struct ip_vs_iphdr *iph);int ip_vs_icmp_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, unsigned int toff, unsigned int hooknum, struct ip_vs_iphdr *ciph);#endif
#ifdef CONFIG_SYSCTL/* This is a simple mechanism to ignore packets when * we are loaded. Just set ip_vs_drop_rate to 'n' and * we start to drop 1/rate of the packets */static inline int ip_vs_todrop(struct netns_ipvs *ipvs){ if (!ipvs->drop_rate) return 0; if (--ipvs->drop_counter > 0) return 0; ipvs->drop_counter = ipvs->drop_rate; return 1;}#elsestatic inline int ip_vs_todrop(struct netns_ipvs *ipvs) { return 0; }#endif
#ifdef CONFIG_SYSCTL/* Enqueue delayed work for expiring no dest connections * Only run when sysctl_expire_nodest=1 */static inline void ip_vs_enqueue_expire_nodest_conns(struct netns_ipvs *ipvs){ if (sysctl_expire_nodest_conn(ipvs)) queue_delayed_work(system_long_wq, &ipvs->expire_nodest_conn_work, 1);}
void ip_vs_expire_nodest_conn_flush(struct netns_ipvs *ipvs);#elsestatic inline void ip_vs_enqueue_expire_nodest_conns(struct netns_ipvs *ipvs) {}#endif
#define IP_VS_DFWD_METHOD(dest) (atomic_read(&(dest)->conn_flags) & \ IP_VS_CONN_F_FWD_MASK)
/* ip_vs_fwd_tag returns the forwarding tag of the connection */#define IP_VS_FWD_METHOD(cp) (cp->flags & IP_VS_CONN_F_FWD_MASK)
static inline char ip_vs_fwd_tag(struct ip_vs_conn *cp){ char fwd;
switch (IP_VS_FWD_METHOD(cp)) { case IP_VS_CONN_F_MASQ: fwd = 'M'; break; case IP_VS_CONN_F_LOCALNODE: fwd = 'L'; break; case IP_VS_CONN_F_TUNNEL: fwd = 'T'; break; case IP_VS_CONN_F_DROUTE: fwd = 'R'; break; case IP_VS_CONN_F_BYPASS: fwd = 'B'; break; default: fwd = '?'; break; } return fwd;}
/* Check if connection uses double hashing */static inline bool ip_vs_conn_use_hash2(struct ip_vs_conn *cp){ return IP_VS_FWD_METHOD(cp) == IP_VS_CONN_F_MASQ && !(cp->flags & IP_VS_CONN_F_TEMPLATE);}
bool ip_vs_nat_icmp(struct sk_buff *skb, struct ip_vs_protocol *pp, struct ip_vs_conn *cp, int dir, unsigned int toff, bool has_ports, struct ip_vs_iphdr *ciph);
#ifdef CONFIG_IP_VS_IPV6void ip_vs_nat_icmp_v6(struct sk_buff *skb, struct ip_vs_protocol *pp, struct ip_vs_conn *cp, int dir, unsigned int toff, bool has_ports, struct ip_vs_iphdr *ciph);#endif
static inline __wsum ip_vs_check_diff4(__be32 old, __be32 new, __wsum oldsum){ __be32 diff[2] = { ~old, new };
return csum_partial(diff, sizeof(diff), oldsum);}
#ifdef CONFIG_IP_VS_IPV6static inline __wsum ip_vs_check_diff16(const __be32 *old, const __be32 *new, __wsum oldsum){ __be32 diff[8] = { ~old[3], ~old[2], ~old[1], ~old[0], new[3], new[2], new[1], new[0] };
return csum_partial(diff, sizeof(diff), oldsum);}#endif
static inline __wsum ip_vs_check_diff2(__be16 old, __be16 new, __wsum oldsum){ __be16 diff[2] = { ~old, new };
return csum_partial(diff, sizeof(diff), oldsum);}
static inline bool ip_vs_checksum_needed(struct sk_buff *skb){ /* Checksum unnecessary or already validated? */ if (skb_csum_unnecessary(skb)) return false; /* Locally generated ? */ if (!skb->dev) return false; return true;}
static inline bool ip_vs_checksum_common_check(struct sk_buff *skb, int offset, int proto, int af){ if (!ip_vs_checksum_needed(skb)) return true; /* Validate csum even for FORWARD */ return !nf_checksum(skb, NF_INET_LOCAL_IN, offset, proto, af);}
/* Forget current conntrack (unconfirmed) and attach notrack entry */static inline void ip_vs_notrack(struct sk_buff *skb){#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE) enum ip_conntrack_info ctinfo; struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
if (ct) { nf_reset_ct(skb); nf_ct_set(skb, NULL, IP_CT_UNTRACKED); }#endif}
#ifdef CONFIG_IP_VS_NFCT/* Netfilter connection tracking * (from ip_vs_nfct.c) */static inline int ip_vs_conntrack_enabled(struct netns_ipvs *ipvs){#ifdef CONFIG_SYSCTL return ipvs->sysctl_conntrack;#else return 0;#endif}
void ip_vs_update_conntrack(struct sk_buff *skb, struct ip_vs_conn *cp, int outin);int ip_vs_confirm_conntrack(struct sk_buff *skb);void ip_vs_nfct_expect_related(struct sk_buff *skb, struct nf_conn *ct, struct ip_vs_conn *cp, u8 proto, const __be16 port, int from_rs);void ip_vs_conn_drop_conntrack(struct ip_vs_conn *cp);
#else
static inline int ip_vs_conntrack_enabled(struct netns_ipvs *ipvs){ return 0;}
static inline void ip_vs_update_conntrack(struct sk_buff *skb, struct ip_vs_conn *cp, int outin){}
static inline int ip_vs_confirm_conntrack(struct sk_buff *skb){ return NF_ACCEPT;}
static inline void ip_vs_conn_drop_conntrack(struct ip_vs_conn *cp){}#endif /* CONFIG_IP_VS_NFCT */
/* Using old conntrack that can not be redirected to another real server? */static inline bool ip_vs_conn_uses_old_conntrack(struct ip_vs_conn *cp, struct sk_buff *skb){#ifdef CONFIG_IP_VS_NFCT enum ip_conntrack_info ctinfo; struct nf_conn *ct;
ct = nf_ct_get(skb, &ctinfo); if (ct && nf_ct_is_confirmed(ct)) return true;#endif return false;}
static inline int ip_vs_register_conntrack(struct ip_vs_service *svc){#if IS_ENABLED(CONFIG_NF_CONNTRACK) int afmask = (svc->af == AF_INET6) ? 2 : 1; int ret = 0;
if (!(svc->conntrack_afmask & afmask)) { ret = nf_ct_netns_get(svc->ipvs->net, svc->af); if (ret >= 0) svc->conntrack_afmask |= afmask; } return ret;#else return 0;#endif}
static inline void ip_vs_unregister_conntrack(struct ip_vs_service *svc){#if IS_ENABLED(CONFIG_NF_CONNTRACK) int afmask = (svc->af == AF_INET6) ? 2 : 1;
if (svc->conntrack_afmask & afmask) { nf_ct_netns_put(svc->ipvs->net, svc->af); svc->conntrack_afmask &= ~afmask; }#endif}
int ip_vs_register_hooks(struct netns_ipvs *ipvs, unsigned int af);void ip_vs_unregister_hooks(struct netns_ipvs *ipvs, unsigned int af);
static inline intip_vs_dest_conn_overhead(struct ip_vs_dest *dest){ /* We think the overhead of processing active connections is 257 * times higher than that of inactive connections in average. (This * 257 times might not be accurate, we will change it later) We * use the following formula to estimate the overhead now: * dest->activeconns*256 + dest->totalconns */ return (atomic_read(&dest->activeconns) << 8) + atomic_read(&dest->totalconns);}
static inline intip_vs_dest_inactconns(const struct ip_vs_dest *dest){ return max(atomic_read(&dest->totalconns) - atomic_read(&dest->activeconns), 0);}
#ifdef CONFIG_IP_VS_PROTO_TCPINDIRECT_CALLABLE_DECLARE(int tcp_snat_handler(struct sk_buff *skb, struct ip_vs_protocol *pp, struct ip_vs_conn *cp, struct ip_vs_iphdr *iph));#endif
#ifdef CONFIG_IP_VS_PROTO_UDPINDIRECT_CALLABLE_DECLARE(int udp_snat_handler(struct sk_buff *skb, struct ip_vs_protocol *pp, struct ip_vs_conn *cp, struct ip_vs_iphdr *iph));#endif#endif /* _NET_IP_VS_H */