IPVS实现分析

  1. IPVS实现分析
  2. 根据LVS官方网站的介绍，LVS支持三种负载均衡模式：NAT，tunnel和direct routing(DR)。
  3. NAT是通用模式，所有交互数据必须通过均衡器；后两种则是一种半连接处理方式，请求数据通过均衡器，而服务器的回应则是直接路由返回的，
  4. 而这两种方法的区别是tunnel模式下由于进行了IP封装所以可路由，而DR方式是修改MAC地址来实现，所以必须同一网段.
  5. [主要数据结构]
  6. 这个结构用来描述IPVS支持的IP协议。IPVS的IP层协议支持TCP, UDP, AH和ESP这4种IP层协议
  7. struct ip_vs_protocol {
  8.         //链表中的下一项
  9.         struct ip_vs_protocol   *next;
  10.         //协议名称, "TCP", "UDP".
  11.         char                    *name;
  12.         //协议值
  13.         __u16                   protocol;
  14.         //不进行分片
  15.         int                     dont_defrag;
  16.         //协议应用计数器,根据是该协议的中多连接协议的数量
  17.         atomic_t                appcnt;
  18.         //协议各状态的超时数组
  19.         int                     *timeout_table;
  20.  
  21.         void (*init)(struct ip_vs_protocol *pp);  //协议初始化
  22.         void (*exit)(struct ip_vs_protocol *pp); //协议释放
  23.         int (*conn_schedule)(struct sk_buff *skb, struct ip_vs_protocol *pp, int *verdict, struct ip_vs_conn **cpp); //协议调度
  24.         //查找in方向的IPVS连接
  25.         struct ip_vs_conn * (*conn_in_get)(const struct sk_buff *skb, struct ip_vs_protocol *pp,
  26.                        const struct iphdr *iph, unsigned int proto_off, int inverse);
  27.         //查找out方向的IPVS连接
  28.         struct ip_vs_conn * (*conn_out_get)(const struct sk_buff *skb, struct ip_vs_protocol *pp,
  29.                         const struct iphdr *iph, unsigned int proto_off, int inverse);
  30.         //源NAT操作
  31.         int (*snat_handler)(struct sk_buff **pskb, struct ip_vs_protocol *pp, struct ip_vs_conn *cp);
  32.         //目的NAT操作
  33.         int (*dnat_handler)(struct sk_buff **pskb, struct ip_vs_protocol *pp, struct ip_vs_conn *cp);
  34.         //协议校验和计算
  35.         int (*csum_check)(struct sk_buff *skb, struct ip_vs_protocol *pp);
  36.         //当前协议状态名称: 如"LISTEN", "ESTABLISH"
  37.         const char *(*state_name)(int state);
  38.         //协议状态迁移
  39.         int (*state_transition)(struct ip_vs_conn *cp, int direction, const struct sk_buff *skb, struct ip_vs_protocol *pp);
  40.         //登记应用
  41.         int (*register_app)(struct ip_vs_app *inc);
  42.         //去除应用登记
  43.         void (*unregister_app)(struct ip_vs_app *inc);
  44.  
  45.         int (*app_conn_bind)(struct ip_vs_conn *cp);
  46.         //数据包打印
  47.         void (*debug_packet)(struct ip_vs_protocol *pp, const struct sk_buff *skb, int offset, const char *msg);
  48.         //调整超时
  49.         void (*timeout_change)(struct ip_vs_protocol *pp, int flags);
  50.         //设置各种状态下的协议超时
  51.         int (*set_state_timeout)(struct ip_vs_protocol *pp, char *sname, int to);
  52. };
  53. 这个结构用来描述IPVS的连接。IPVS的连接和netfilter定义的连接类似
  54. struct ip_vs_conn {
  55.         struct list_head         c_list;            //HASH链表
  56.         __u32                   caddr;          //客户机地址
  57.         __u32                   vaddr;          //服务器对外的虚拟地址
  58.         __u32                   daddr;          //服务器实际地址
  59.         __u16                   cport;          //客户端的端口
  60.         __u16                   vport;         //服务器对外虚拟端口
  61.         __u16                   dport;         //服务器实际端口
  62.         __u16                   protocol;      //协议类型
  63.  
  64.         atomic_t                refcnt;        //连接引用计数
  65.         struct timer_list       timer;           //定时器
  66.         volatile unsigned long  timeout;       //超时时间
  67.  
  68.         spinlock_t              lock;           //状态转换锁
  69.         volatile __u16          flags;          /* status flags */
  70.         volatile __u16          state;          /* state info */
  71.  
  72.         struct ip_vs_conn       *control;       //主连接, 如FTP
  73.         atomic_t                n_control;      //子连接数
  74.         struct ip_vs_dest       *dest;          //真正服务器
  75.         atomic_t                in_pkts;        //进入的数据统计
  76.  
  77.         int (*packet_xmit)(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); //数据包发送
  78.  
  79.         struct ip_vs_app        *app;           //IPVS应用
  80.         void                    *app_data;      //应用的私有数据
  81.         struct ip_vs_seq        in_seq;         //进入数据的序列号
  82.         struct ip_vs_seq        out_seq;       //发出数据的序列号
  83. };
  84. 这个结构用来描述IPVS对外的虚拟服务器信息
  85. struct ip_vs_service {
  86.         struct list_head        s_list;        //按普通协议,地址,端口进行HASH的链表
  87.         struct list_head        f_list;        //按nfmark进行HASH的链表
  88.         atomic_t                refcnt;      //引用计数
  89.         atomic_t                usecnt;      //使用计数
  90.  
  91.         __u16                   protocol;   //协议
  92.         __u32                   addr;       //虚拟服务器地址
  93.         __u16                   port;       //虚拟服务器端口
  94.         __u32                   fwmark;    //就是skb中的nfmark
  95.         unsigned                flags;       //状态标志
  96.         unsigned                timeout;     //超时
  97.         __u32                   netmask;    //网络掩码
  98.  
  99.         struct list_head        destinations;  //真实服务器的地址链表
  100.         __u32                  num_dests;  //真实服务器的数量
  101.         struct ip_vs_stats      stats;        //服务统计信息
  102.         struct ip_vs_app        *inc;         //应用
  103.  
  104.         struct ip_vs_scheduler  *scheduler;    //调度指针
  105.         rwlock_t                sched_lock;    //调度锁
  106.         void                    *sched_data;   //调度私有数据
  107. };
  108. 这个结构用来描述具体的真实服务器的信息
  109. struct ip_vs_dest {
  110.         struct list_head        n_list;   /* for the dests in the service */
  111.         struct list_head        d_list;   /* for table with all the dests */
  112.  
  113.         __u32                   addr;           //服务器地址
  114.         __u16                   port;           //服务器端口
  115.         volatile unsigned        flags;          //目标标志,易变参数
  116.         atomic_t                conn_flags;     //连接标志
  117.         atomic_t                weight;         //服务器权重
  118.  
  119.         atomic_t                refcnt;         //引用计数
  120.         struct ip_vs_stats      stats;          //统计数
  121.  
  122.         atomic_t                activeconns;    //活动的连接
  123.         atomic_t                inactconns;     //不活动的连接
  124.         atomic_t                persistconns;   //保持的连接，常驻
  125.         __u32                   u_threshold;   //连接上限
  126.         __u32                   l_threshold;    //连接下限
  127.  
  128.         /* for destination cache */
  129.         spinlock_t              dst_lock;       /* lock of dst_cache */
  130.         struct dst_entry        *dst_cache;     /* destination cache entry */
  131.         u32                     dst_rtos;
  132.         struct ip_vs_service    *svc;           /* service it belongs to */
  133.         __u16                   protocol;       /* which protocol (TCP/UDP) */
  134.         __u32                   vaddr;          /* virtual IP address */
  135.         __u16                   vport;          /* virtual port number */
  136.         __u32                   vfwmark;        /* firewall mark of service */
  137. };
  138. 这个结构用来描述IPVS调度算法，目前调度方法包括rr，wrr，lc, wlc, lblc, lblcr, dh, sh等
  139. struct ip_vs_scheduler {
  140.         struct list_head        n_list;         /* d-linked list head */
  141.         char                    *name;          /* scheduler name */
  142.         atomic_t                refcnt;         /* reference counter */
  143.         struct module           *module;        /* THIS_MODULE/NULL */
  144.  
  145.         /* scheduler initializing service */
  146.         int (*init_service)(struct ip_vs_service *svc);
  147.         /* scheduling service finish */
  148.         int (*done_service)(struct ip_vs_service *svc);
  149.         /* scheduler updating service */
  150.         int (*update_service)(struct ip_vs_service *svc);
  151.  
  152.         /* selecting a server from the given service */
  153.         struct ip_vs_dest* (*schedule)(struct ip_vs_service *svc, const struct sk_buff *skb);
  154. };
  155.  
  156. IPVS应用是针对多连接协议的, 目前也就只支持FTP。
  157. 由于ip_vs_app.c是从2.2过来的，没有管内核是否本身有NAT的情况，所以相当于自身实现了应用协议的NAT处理，包 括内容信息的改变，
  158. TCP序列号确认号的调整等，而现在这些都由netfilter实现了，IPVS可以不用管这些，只处理连接调度就行了。
  159. IPVS的应用模块化还不是很好，在处理连接端口时，还要判断是否是FTPPORT，也就是说不支持其他多连接协议的，
  160. 应该象netfilter一样为每个多连接协议设置一个helper，自动调用，不用在程序里判断端口。
  161.  
  162. struct ip_vs_app
  163. {
  164.         struct list_head        a_list;           //用来挂接到应用链表
  165.         int                     type;           /* IP_VS_APP_TYPE_xxx */
  166.         char                    *name;          /* application module name */
  167.         __u16                   protocol;      //协议, TCP, UD
  168.         struct module           *module;        /* THIS_MODULE/NULL */
  169.         struct list_head        incs_list;        //应用的具体实例链表
  170.  
  171.         /* members for application incarnations */
  172.         struct list_head        p_list;         //将应用结构挂接到对应协议(TCP, UDP...)的应用表
  173.         struct ip_vs_app        *app;           /* its real application */
  174.         __u16                   port;           /* port number in net order */
  175.         atomic_t                usecnt;         /* usage counter */
  176.  
  177.         /* output hook: return false if can't linearize. diff set for TCP.  */
  178.         int (*pkt_out)(struct ip_vs_app *, struct ip_vs_conn *, struct sk_buff **, int *diff);
  179.         /* input hook: return false if can't linearize. diff set for TCP. */
  180.         int (*pkt_in)(struct ip_vs_app *, struct ip_vs_conn *, struct sk_buff **, int *diff);
  181.         /* ip_vs_app initializer */
  182.         int (*init_conn)(struct ip_vs_app *, struct ip_vs_conn *);
  183.         /* ip_vs_app finish */
  184.         int (*done_conn)(struct ip_vs_app *, struct ip_vs_conn *);
  185.         /* not used now */
  186.         int (*bind_conn)(struct ip_vs_app *, struct ip_vs_conn *, struct ip_vs_protocol *);
  187.         void (*unbind_conn)(struct ip_vs_app *, struct ip_vs_conn *);
  188.  
  189.         int *                   timeout_table;
  190.         int *                   timeouts;
  191.         int                     timeouts_size;
  192.  
  193.         int (*conn_schedule)(struct sk_buff *skb, struct ip_vs_app *app, int *verdict, struct ip_vs_conn **cpp);
  194.         struct ip_vs_conn *
  195.         (*conn_in_get)(const struct sk_buff *skb, struct ip_vs_app *app, const struct iphdr *iph, unsigned int proto_off, int inverse);
  196.         struct ip_vs_conn *
  197.         (*conn_out_get)(const struct sk_buff *skb, struct ip_vs_app *app, const struct iphdr *iph, unsigned int proto_off, int inverse);
  198.         int (*state_transition)(struct ip_vs_conn *cp, int direction, const struct sk_buff *skb, struct ip_vs_app *app);
  199.         void (*timeout_change)(struct ip_vs_app *app, int flags);
  200. };
  201. 用户空间信息是ipvsadm程序接收用户输入后传递给内核ipvs的信息，信息都是很直接的，没有各种控制信息。
  202. ipvsadm和ipvs的关系相当于iptables和netfilter的关系.
  203.  
  204. 用户空间的虚拟服务信息
  205. struct ip_vs_service_user {
  206.         /* virtual service addresses */
  207.         u_int16_t               protocol;
  208.         u_int32_t               addr;           /* virtual ip address */
  209.         u_int16_t               port;
  210.         u_int32_t               fwmark;         /* firwall mark of service */
  211.  
  212.         /* virtual service options */
  213.         char                    sched_name[IP_VS_SCHEDNAME_MAXLEN];
  214.         unsigned                flags;          /* virtual service flags */
  215.         unsigned                timeout;        /* persistent timeout in sec */
  216.         u_int32_t               netmask;        /* persistent netmask */
  217. };
  218. 用户空间的真实服务器信息
  219. struct ip_vs_dest_user {
  220.         /* destination server address */
  221.         u_int32_t               addr;
  222.         u_int16_t               port;
  223.         /* real server options */
  224.         unsigned                conn_flags;     /* connection flags */
  225.         int                     weight;         /* destination weight */
  226.         /* thresholds for active connections */
  227.         u_int32_t               u_threshold;    /* upper threshold */
  228.         u_int32_t               l_threshold;    /* lower threshold */
  229. };
  230. 用户空间的统计信息
  231. struct ip_vs_stats_user
  232. {
  233.         __u32                   conns;          /* connections scheduled */
  234.         __u32                   inpkts;         /* incoming packets */
  235.         __u32                   outpkts;        /* outgoing packets */
  236.         __u64                   inbytes;        /* incoming bytes */
  237.         __u64                   outbytes;       /* outgoing bytes */
  238.         __u32                   cps;            /* current connection rate */
  239.         __u32                   inpps;          /* current in packet rate */
  240.         __u32                   outpps;         /* current out packet rate */
  241.         __u32                   inbps;          /* current in byte rate */
  242.         __u32                   outbps;         /* current out byte rate */
  243. };
  244. 用户空间的获取信息结构
  245. struct ip_vs_getinfo {
  246.         /* version number */
  247.         unsigned int            version;
  248.         /* size of connection hash table */
  249.         unsigned int            size;
  250.         /* number of virtual services */
  251.         unsigned int            num_services;
  252. };
  253. 用户空间的服务规则项信息
  254. struct ip_vs_service_entry {
  255.         /* which service: user fills in these */
  256.         u_int16_t               protocol;
  257.         u_int32_t               addr;           /* virtual address */
  258.         u_int16_t               port;
  259.         u_int32_t               fwmark;         /* firwall mark of service */
  260.  
  261.         /* service options */
  262.         char                    sched_name[IP_VS_SCHEDNAME_MAXLEN];
  263.         unsigned                flags;          /* virtual service flags */
  264.         unsigned                timeout;        /* persistent timeout */
  265.         u_int32_t               netmask;        /* persistent netmask */
  266.  
  267.         /* number of real servers */
  268.         unsigned int            num_dests;
  269.         /* statistics */
  270.         struct ip_vs_stats_user stats;
  271. };
  272. 用户空间的服务器项信息
  273. struct ip_vs_dest_entry {
  274.         u_int32_t               addr;           /* destination address */
  275.         u_int16_t               port;
  276.         unsigned                conn_flags;     /* connection flags */
  277.         int                     weight;         /* destination weight */
  278.  
  279.         u_int32_t               u_threshold;    /* upper threshold */
  280.         u_int32_t               l_threshold;    /* lower threshold */
  281.  
  282.         u_int32_t               activeconns;    /* active connections */
  283.         u_int32_t               inactconns;     /* inactive connections */
  284.         u_int32_t               persistconns;   /* persistent connections */
  285.  
  286.         /* statistics */
  287.         struct ip_vs_stats_user stats;
  288. };
  289. 用户空间的获取服务器项信息
  290. struct ip_vs_get_dests {
  291.         /* which service: user fills in these */
  292.         u_int16_t               protocol;
  293.         u_int32_t               addr;           /* virtual address */
  294.         u_int16_t               port;
  295.         u_int32_t               fwmark;         /* firwall mark of service */
  296.  
  297.         /* number of real servers */
  298.         unsigned int            num_dests;
  299.  
  300.         /* the real servers */
  301.         ];
  302. };
  303. 用户空间的获取虚拟服务项信息
  304. struct ip_vs_get_services {
  305.         /* number of virtual services */
  306.         unsigned int            num_services;
  307.         /* service table */
  308.         ];
  309. };
  310. 用户空间的获取超时信息结构
  311. struct ip_vs_timeout_user {
  312.         int                     tcp_timeout;
  313.         int                     tcp_fin_timeout;
  314.         int                     udp_timeout;
  315. };
  316. 用户空间的获取IPVS内核守护进程信息结构
  317. struct ip_vs_daemon_user {
  318.         /* sync daemon state (master/backup) */
  319.         int                     state;
  320.         /* multicast interface name */
  321.         char                    mcast_ifn[IP_VS_IFNAME_MAXLEN];
  322.         /* SyncID we belong to */
  323.         int                     syncid;
  324. };
  325. [/主要数据结构]
  326. static int __init ip_vs_init(void)
  327. {
  328.       int ret;
  329.  
  330.       //初始化ipvs的控制接口，set/get sockopt操作
  331.       ret = ip_vs_control_init();
  332. ) {
  333.             IP_VS_ERR("can't setup control.\n");
  334.             goto cleanup_nothing;
  335.       }
  336.       //协议初始化
  337.       ip_vs_protocol_init();
  338.       //应用层辅助接口初始化
  339.       ret = ip_vs_app_init();
  340. ) {
  341.             IP_VS_ERR("can't setup application helper.\n");
  342.             goto cleanup_protocol;
  343.       }
  344.       //主要数据结构初始化
  345.       ret = ip_vs_conn_init();
  346. ) {
  347.             IP_VS_ERR("can't setup connection table.\n");
  348.             goto cleanup_app;
  349.       }
  350.       //下面分别挂接各个处理点到netfilter架构中，看下面hook点实现
  351.       //关于hook点知识，参考ip_conntrack实现
  352.       ret = nf_register_hook(&ip_vs_in_ops);
  353. ) {
  354.             IP_VS_ERR("can't register in hook.\n");
  355.             goto cleanup_conn;
  356.       }
  357.       ret = nf_register_hook(&ip_vs_out_ops);
  358. ) {
  359.             IP_VS_ERR("can't register out hook.\n");
  360.             goto cleanup_inops;
  361.       }
  362.       ret = nf_register_hook(&ip_vs_post_routing_ops);
  363. ) {
  364.             IP_VS_ERR("can't register post_routing hook.\n");
  365.             goto cleanup_outops;
  366.       }
  367.       ret = nf_register_hook(&ip_vs_forward_icmp_ops);
  368. ) {
  369.             IP_VS_ERR("can't register forward_icmp hook.\n");
  370.             goto cleanup_postroutingops;
  371.       }
  372.  
  373.       IP_VS_INFO("ipvs loaded.\n");
  374.       return ret;
  375.       ......
  376. }
  377. 控制接口初始化
  378. int ip_vs_control_init(void)
  379. {
  380.       int ret;
  381.       int idx;
  382.       //登记ipvs的sockopt控制,这样用户空间可通过setsockopt函数来和ipvs进行通信，看下面控制接口实现
  383.       ret = nf_register_sockopt(&ip_vs_sockopts);
  384.       if (ret) {
  385.            IP_VS_ERR("cannot register sockopt.\n");
  386.            return ret;
  387.       }
  388.       //建立/proc/net/ip_vs和/proc/net/ip_vs_stats只读项
  389.       //看下面控制接口实现
  390.       proc_net_fops_create(, &ip_vs_info_fops);
  391.       proc_net_fops_create(, &ip_vs_stats_fops);
  392.  
  393.       //建立/proc/sys/net/ipv4/vs目录下的各可读写控制参数
  394.       sysctl_header = register_sysctl_table(vs_root_table, );
  395.  
  396.       //初始化各种双向链表
  397.       //svc_table是根据协议地址端口等信息进行服务结构struct ip_vs_service查找的HASH表
  398.       //svc_fwm_table是根据数据包的nfmark信息进行服务结构struct ip_vs_service查找的HASH表
  399. ; idx < IP_VS_SVC_TAB_SIZE; idx++)  {
  400.             INIT_LIST_HEAD(&ip_vs_svc_table[idx]);
  401.             INIT_LIST_HEAD(&ip_vs_svc_fwm_table[idx]);
  402.       }
  403.       //rtable是目的结构struct ip_vs_dest的HASH链表
  404. ; idx < IP_VS_RTAB_SIZE; idx++)  {
  405.             INIT_LIST_HEAD(&ip_vs_rtable[idx]);
  406.       }
  407.       //ipvs统计信息
  408.       memset(&ip_vs_stats, , sizeof(ip_vs_stats));
  409.       spin_lock_init(&ip_vs_stats.lock);              //统计锁
  410.       //对当前统计信息建立一个预估器,可用于计算服务器的性能参数
  411.       ip_vs_new_estimator(&ip_vs_stats);
  412.       //挂一个定时操作，根据系统当前负载情况定时调整系统参数
  413.       schedule_delayed_work(&defense_work, DEFENSE_TIMER_PERIOD);
  414. ;
  415. }
  416. //协议初始化，具体看下面协议实现
  417. int ip_vs_protocol_init(void)
  418. {
  419.       //挂接ipvs能进行均衡处理的各种协议,目前支持TCP/UDP/AH/ESP
  420. ];
  421. #define REGISTER_PROTOCOL(p)                    \
  422.       do {                                    \
  423.             register_ip_vs_protocol(p);     \
  424.             strcat(protocols, ", ");        \
  425.             strcat(protocols, (p)->name);   \
  426.       } )
  427.  
  428.       //0,1字符是给", "预留的
  429.       protocols[] = '\0';
  430.       protocols[] = '\0';
  431. #ifdef CONFIG_IP_VS_PROTO_TCP
  432.       REGISTER_PROTOCOL(&ip_vs_protocol_tcp);
  433. #endif
  434. #ifdef CONFIG_IP_VS_PROTO_UDP
  435.       REGISTER_PROTOCOL(&ip_vs_protocol_udp);
  436. #endif
  437. #ifdef CONFIG_IP_VS_PROTO_AH
  438.       REGISTER_PROTOCOL(&ip_vs_protocol_ah);
  439. #endif
  440. #ifdef CONFIG_IP_VS_PROTO_ESP
  441.       REGISTER_PROTOCOL(&ip_vs_protocol_esp);
  442. #endif
  443.       IP_VS_INFO(]);
  444. ;
  445. }
  446. #define IP_VS_PROTO_TAB_SIZE  32
  447. static int register_ip_vs_protocol(struct ip_vs_protocol *pp)
  448. {
  449.         //#define IP_VS_PROTO_HASH(proto)         ((proto) & (IP_VS_PROTO_TAB_SIZE-1))
  450.         unsigned hash = IP_VS_PROTO_HASH(pp->protocol); //计算一个hash值
  451.  
  452.         pp->next = ip_vs_proto_table[hash];
  453.         ip_vs_proto_table[hash] = pp;
  454.  
  455.         if (pp->init != NULL)
  456.                 pp->init(pp);
  457.         ;
  458. }
  459. 应用层辅助接口初始化
  460. int ip_vs_app_init(void)
  461. {
  462.         //建立一个/proc/net/ip_vs_app项
  463.         proc_net_fops_create(, &ip_vs_app_fops);
  464.         ;
  465. }
  466. 主要数据结构初始化
  467. int ip_vs_conn_init(void)
  468. {
  469.       int idx;
  470.       //ipvs连接HASH表 static struct list_head *ip_vs_conn_tab;
  471.       ip_vs_conn_tab = vmalloc(IP_VS_CONN_TAB_SIZE*sizeof(struct list_head));
  472.       if (!ip_vs_conn_tab)
  473. return -ENOMEM;
  474.  
  475.       //ipvs连接cache
  476.       ip_vs_conn_cachep = kmem_cache_create(, SLAB_HWCACHE_ALIGN, NULL, NULL);
  477.       if (!ip_vs_conn_cachep) {
  478.             vfree(ip_vs_conn_tab);
  479.             return -ENOMEM;
  480.       }
  481.       //初始化HASH链表头
  482. ; idx < IP_VS_CONN_TAB_SIZE; idx++) {
  483.             INIT_LIST_HEAD(&ip_vs_conn_tab[idx]);
  484.       }
  485.       //初始化各读写锁
  486. ; idx < CT_LOCKARRAY_SIZE; idx++)  {
  487.             rwlock_init(&__ip_vs_conntbl_lock_array[idx].l);
  488.       }
  489.       //建立/proc/net/ip_vs_conn项
  490.       proc_net_fops_create(, &ip_vs_conn_fops);
  491.       //初始化随机数
  492.       get_random_bytes(&ip_vs_conn_rnd, sizeof(ip_vs_conn_rnd));
  493. ;
  494. }
  495.  
  496. [hook点实现]
  497. 我们一个一个看
  498. static struct nf_hook_ops ip_vs_in_ops = {
  499.         .hook           = ip_vs_in,
  500.         .owner          = THIS_MODULE,
  501.         .pf             = PF_INET,
  502.         .hooknum        = NF_IP_LOCAL_IN,
  503.         .priority       = ,
  504. };
  505. static unsigned int ip_vs_in(unsigned int hooknum, struct sk_buff **pskb, const struct net_device *in, const struct net_device * out, int (*okfn)(struct sk_buff *))
  506. {
  507.       struct sk_buff  *skb = *pskb;
  508.       struct iphdr    *iph;
  509.       struct ip_vs_protocol *pp;
  510.       struct ip_vs_conn *cp;
  511.       int ret, restart;
  512.       int ihl;
  513.       //不处理目的非本机的包
  514.       if (unlikely(skb->pkt_type != PACKET_HOST || skb->dev == &loopback_dev || skb->sk)) {
  515.             IP_VS_DBG(, "packet type=%d proto=%d daddr=%d.%d.%d.%d ignored\n",
  516.             skb->pkt_type, skb->nh.iph->protocol, NIPQUAD(skb->nh.iph->daddr));
  517.             return NF_ACCEPT;
  518.       }
  519.       iph = skb->nh.iph;
  520.       if (unlikely(iph->protocol == IPPROTO_ICMP)) {
  521.             //如果是ICMP，可能是指示连接错误的ICMP信息，调用ip_vs_in_icmp进行检查是否是相关的ICMP信息
  522.             int related, verdict = ip_vs_in_icmp(pskb, &related, hooknum);
  523.  
  524.             if (related)
  525.                   return verdict;
  526.  
  527.            //非相关ICMP，恢复处理流程
  528.            // 但其实ipvs是不均衡ICMP信息的，后面就返回了
  529.            skb = *pskb;
  530.            iph = skb->nh.iph;
  531.       }
  532.       //获取协议支持模块，由于只支持TCP、UDP、AH和ESP，如果是ICMP，返回为NULL
  533.       pp = ip_vs_proto_get(iph->protocol);
  534.       if (unlikely(!pp))
  535.             return NF_ACCEPT;
  536.  
  537.       ihl = iph->ihl << ; //ip头长度
  538.  
  539.       //找到和该skb相关的ipvs连接，类似netfilter的根据tuple查找连接，
  540.       //不过sk_buff结构中没有增加nfct那样能直接指向连接的成员
  541.       //对TCP协议来说是tcp_conn_in_get()，看下面协议实现
  542.       cp = pp->conn_in_get(skb, pp, iph, ihl, );
  543.       if (unlikely(!cp)) {
  544.             int v;
  545.             //如果没有连接, 表明是新连接, 调用IPVS连接的conn_schedule为连接分配和处理连接调度,
  546.             //要根据调度算法选择一个真实目的服务器，然后建立新的IPVS连接
  547.             //对TCP协议来说是tcp_conn_schedule()
  548.             if (!pp->conn_schedule(skb, pp, &v, &cp))
  549.                   return v;
  550.       }
  551.       if (unlikely(!cp)) { //这种情况主要是没内存空间了，IPVS没提供主动删除连接的机制
  552.             IP_VS_DBG_PKT(, pp, skb, , "packet continues traversal as normal");
  553. return NF_ACCEPT;
  554.       }
  555.       //对于目的服务器失效的包丢弃
  556.       if (cp->dest && !(cp->dest->flags & IP_VS_DEST_F_AVAILABLE)) {
  557.             if (sysctl_ip_vs_expire_nodest_conn) {
  558.                   /* try to expire the connection immediately */
  559.                   ip_vs_conn_expire_now(cp);
  560.             }
  561.             __ip_vs_conn_put(cp);
  562.             return NF_DROP;
  563.       }
  564.       //连接信息统计
  565.       ip_vs_in_stats(cp, skb);
  566.  
  567.       //进行连接状态的迁移, restart这个参数其实没用
  568.       //对TCP协议来说是调用tcp_state_transition
  569.       restart = ip_vs_set_state(cp, IP_VS_DIR_INPUT, skb, pp);
  570.       if (cp->packet_xmit)
  571.             //将包发送出去, 具体xmit的实现在ip_vs_xmit.c中实现,
  572.             //NAT模式下为 ip_vs_nat_xmit;
  573.             //通道模式下为 ip_vs_tunnel_xmit;
  574.             //直接路由模式下为: ip_vs_dr_xmit;
  575.             //本机数据为: ip_vs_null_xmit;
  576.             //旁路模式下为: ip_vs_bypass_xmit;
  577.             //函数成功时基本都返回NF_STOLEN使netfilter不再处理该包
  578.             //所以对于NAT模式，应该是不需要配置DNAT规则的，请求方向数据也不经过FORWARD链
  579.             ret = cp->packet_xmit(skb, cp, pp);
  580.       else {
  581.             IP_VS_DBG_RL("warning: packet_xmit is null");
  582.             ret = NF_ACCEPT;
  583.       }
  584.       atomic_inc(&cp->in_pkts); //增加进入包计数器
  585.  
  586.       //在进行均衡器热备时将连接信息要从MASTER传递到SLAVE，使系统切换时
  587.       //连接不丢弃，但还是要有一定条件才进行同步
  588.       if ((ip_vs_sync_state & IP_VS_STATE_MASTER) //同步状态类型为主机
  589.             && (cp->protocol != IPPROTO_TCP || cp->state == IP_VS_TCP_S_ESTABLISHED) && //非TCP连接或是已经建立的连接
  590.             //当前连接的包数适当时
  591.             (atomic_read(&cp->in_pkts) % sysctl_ip_vs_sync_threshold[] == sysctl_ip_vs_sync_threshold[]))
  592.  
  593.       ip_vs_sync_conn(cp); //进行连接的同步，看下面IPVS的同步
  594.  
  595.       //调整连接超时,释放连接计数
  596.       ip_vs_conn_put(cp);
  597.       return ret;
  598. }
  599. static struct nf_hook_ops ip_vs_out_ops = {
  600.         .hook           = ip_vs_out,
  601.         .owner          = THIS_MODULE,
  602.         .pf             = PF_INET,
  603.         .hooknum        = NF_IP_FORWARD,
  604.         .priority       = ,
  605. };
  606. 这个函数对转发包进行处理, 只用在NAT模式的均衡处理，TUNNEL和DR方式下都是直接发送了，
  607. 实际处理的只是服务器返回的回应包，而客户端请求的包是不经过这里的，
  608. 但如果设置了DNAT规则，数据包在PREROUTING点进行了目的地址修改，这样就不会再进入INPUT点而是直接转到FORWARD点处理，
  609. 这时时针对该包的 IPVS连接是没有建立的.
  610. static unsigned int ip_vs_out(unsigned int hooknum, struct sk_buff **pskb, const struct net_device *in, const struct net_device *out, int (*okfn)(struct sk_buff *))
  611. {
  612.       struct sk_buff  *skb = *pskb;
  613.       struct iphdr    *iph;
  614.       struct ip_vs_protocol *pp;
  615.       struct ip_vs_conn *cp;
  616.       int ihl;
  617.  
  618.       //这个标志只占一位，标志置位就是已经经过IPVS处理了，直接返回
  619.       if (skb->ipvs_property)
  620.             return NF_ACCEPT;
  621.  
  622.       iph = skb->nh.iph;
  623.       if (unlikely(iph->protocol == IPPROTO_ICMP)) {
  624.             //处理可能的连接相关ICMP错误信息,如地址端口不可达等
  625. int related, verdict = ip_vs_out_icmp(pskb, &related);
  626.             if (related)
  627.                   return verdict;
  628.  
  629.             skb = *pskb;
  630.             iph = skb->nh.iph;
  631.       }
  632.       //取得IPVS协议, tcp/udp/ah/esp之一
  633.       pp = ip_vs_proto_get(iph->protocol);
  634.       if (unlikely(!pp))
  635.             return NF_ACCEPT;
  636.  
  637.       //如果是碎片包进行重组,基本不可能,因为数据包进入netfilter时就要进行碎片重组
  638. if (unlikely(iph->frag_off & __constant_htons(IP_MF|IP_OFFSET) && !pp->dont_defrag)) {
  639.             skb = ip_vs_gather_frags(skb, IP_DEFRAG_VS_OUT);
  640.  
  641.             if (!skb)
  642.                   return NF_STOLEN;
  643.  
  644.             iph = skb->nh.iph;
  645.             *pskb = skb;
  646.       }
  647.       ihl = iph->ihl << ; //ip头长度
  648.       //查找IPVS连接
  649.       cp = pp->conn_out_get(skb, pp, iph, ihl, );
  650.       if (unlikely(!cp)) { //没有找到，可能是请求方向的包经过DNAT过来的
  651.             if (sysctl_ip_vs_nat_icmp_send && (pp->protocol == IPPROTO_TCP || pp->protocol == IPPROTO_UDP)) {
  652.                   __u16 _ports[], *pptr;
  653.                   pptr = skb_header_pointer(skb, ihl, sizeof(_ports), _ports);
  654.                   if (pptr == NULL)
  655.                         return NF_ACCEPT;
  656.  
  657.                   //用源地址，源端口来查真实服务器结构，如果是请求方向是找不到的
  658.                   //这种情况下数据包就不再被IPVS处理
  659. ])) {
  660.                         if (iph->protocol != IPPROTO_TCP || !is_tcp_reset(skb)) {
  661.                               icmp_send(skb,ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, ); //发送icmp不可达信息
  662.                               return NF_DROP;
  663.                         }
  664.                   }
  665.  
  666.             }
  667.             return NF_ACCEPT;
  668.  
  669.       }
  670.       //找到连接，该包是服务器的回应包
  671.       //skb数据包要求是可写的
  672.       if (!ip_vs_make_skb_writable(pskb, ihl))
  673.             goto drop;
  674.  
  675.       //修改协议部分信息，如TCP、UDP的端口
  676.       if (pp->snat_handler && !pp->snat_handler(pskb, pp, cp))
  677.              goto drop;
  678.       skb = *pskb;
  679.       //修改源地址, 由于是服务器的返回包，只修改源地址
  680.       skb->nh.iph->saddr = cp->vaddr;
  681.       ip_send_check(skb->nh.iph); //重新计算校验和
  682.  
  683.       //重新计算路由信息，对于本地产生的数据包
  684. )
  685.             goto drop;
  686.  
  687.       skb = *pskb;
  688.       //PVS输出统计
  689.       ip_vs_out_stats(cp, skb);
  690.       ip_vs_set_state(cp, IP_VS_DIR_OUTPUT, skb, pp); //状态迁移
  691.       ip_vs_conn_put(cp); //调整连接超时,释放连接计数
  692.  
  693.       skb->ipvs_property = ; //对该包设置标志表示IPVS处理过了
  694.  
  695.       return NF_ACCEPT;
  696. drop:
  697.       ip_vs_conn_put(cp);
  698.       kfree_skb(*pskb);
  699.       return NF_STOLEN;
  700. }
  701.  
  702. static struct nf_hook_ops ip_vs_forward_icmp_ops = {
  703.         .hook           = ip_vs_forward_icmp,
  704.         .owner          = THIS_MODULE,
  705.         .pf             = PF_INET,
  706.         .hooknum        = NF_IP_FORWARD,
  707.         .priority       = , //在ip_vs_out_ops之前进行
  708. };
  709. //这个函数对转发的ICMP包进行处理, 处理由于服务器失效而引起的网络或端口不可达的ICMP信息,其他和服务器无关的ICMP信息不处理.
  710. static unsigned int ip_vs_forward_icmp(unsigned int hooknum, struct sk_buff **pskb, const struct net_device *in,
  711.                                        const struct net_device *out, int (*okfn)(struct sk_buff *))
  712. {
  713.         int r;
  714.  
  715.         if ((*pskb)->nh.iph->protocol != IPPROTO_ICMP)
  716.                 return NF_ACCEPT;
  717.  
  718.         return ip_vs_in_icmp(pskb, &r, hooknum);
  719. }
  720. static int ip_vs_in_icmp(struct sk_buff **pskb, int *related, unsigned int hooknum)
  721. {
  722.       struct sk_buff *skb = *pskb;
  723.       struct iphdr *iph;
  724.       struct icmphdr  _icmph, *ic;
  725.       struct iphdr    _ciph, *cih;    /* The ip header contained within the ICMP */
  726.       struct ip_vs_conn *cp;
  727.       struct ip_vs_protocol *pp;
  728.       unsigned int offset, ihl, verdict;
  729.  
  730.       *related = ; //这个参数指示该ICMP包是否和IPVS的连接相关，好像没用
  731.  
  732.       if (skb->nh.iph->frag_off & __constant_htons(IP_MF|IP_OFFSET)) {
  733.             //进行碎片重组
  734.             skb = ip_vs_gather_frags(skb, hooknum == NF_IP_LOCAL_IN ? IP_DEFRAG_VS_IN : IP_DEFRAG_VS_FWD);
  735.             if (!skb)
  736.                   return NF_STOLEN;
  737.             *pskb = skb;
  738.       }
  739.       iph = skb->nh.iph; //ip头
  740.       offset = ihl = iph->ihl * ; //数据开始
  741.       //获取icmp头
  742.       ic = skb_header_pointer(skb, offset, sizeof(_icmph), &_icmph);
  743.       if (ic == NULL)
  744.             return NF_DROP;
  745.       //如果不是这三种ICMP信息,则该skb与IPVS无关
  746.       if ((ic->type != ICMP_DEST_UNREACH) && (ic->type != ICMP_SOURCE_QUENCH) && (ic->type != ICMP_TIME_EXCEEDED)) {
  747.             *related = ;
  748.             return NF_ACCEPT;
  749.       }
  750.  
  751.       offset += sizeof(_icmph); //获取ip头
  752.       cih = skb_header_pointer(skb, offset, sizeof(_ciph), &_ciph);
  753.       if (cih == NULL)
  754.             return NF_ACCEPT;
  755.       //找的是ICMP信息中包含的原始包中的协议,而不是ICMP
  756.       pp = ip_vs_proto_get(cih->protocol);
  757.       if (!pp)
  758.             return NF_ACCEPT;
  759.       //如果是碎片包且定义了不处理标志则直接返回
  760.       if (unlikely(cih->frag_off & __constant_htons(IP_OFFSET) && pp->dont_defrag))
  761.             return NF_ACCEPT;
  762.       offset += cih->ihl * ; // + ip头长度
  763.       //查找IPVS连接
  764.       cp = pp->conn_in_get(skb, pp, cih, offset, );
  765.       if (!cp)
  766.             return NF_ACCEPT;
  767.       //缺省的裁定结果是丢弃包
  768.       verdict = NF_DROP;
  769.       //检查ip校验和
  770.       if (skb->ip_summed != CHECKSUM_UNNECESSARY && ip_vs_checksum_complete(skb, ihl)) {
  771.             IP_VS_DBG(, "Incoming ICMP: failed checksum from %d.%d.%d.%d!\n", NIPQUAD(iph->saddr));
  772.             goto out;
  773.       }
  774.       ip_vs_in_stats(cp, skb);//进行输入统计
  775.       //如果内部协议是TCP/UDP,发送偏移量要包括前4个字节: 源端口和目的端口
  776.       if (IPPROTO_TCP == cih->protocol || IPPROTO_UDP == cih->protocol)
  777.             offset +=  * sizeof(__u16);
  778.       //发送ICMP
  779.       verdict = ip_vs_icmp_xmit(skb, cp, pp, offset);
  780. out:
  781.       __ip_vs_conn_put(cp);
  782.       return verdict;
  783. }
  784. 发送各种ICMP错误信息包
  785. int ip_vs_icmp_xmit(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, int offset)
  786. {
  787.       struct rtable   *rt;    /* Route to the other host */
  788.       int mtu;
  789.       int rc;
  790.       //如果不是NAT情况的IPVS连接, 即是TUNNEL或DR，直接调用连接的发送函数发送
  791.       if (IP_VS_FWD_METHOD(cp) != IP_VS_CONN_F_MASQ) {
  792.             if (cp->packet_xmit)
  793.                   rc = cp->packet_xmit(skb, cp, pp);
  794.             else
  795.                   rc = NF_ACCEPT;
  796.  
  797.             /* do not touch skb anymore */
  798.             atomic_inc(&cp->in_pkts);
  799.             goto out;
  800.       }
  801.       //查找路由
  802.       if (!(rt = __ip_vs_get_out_rt(cp, RT_TOS(skb->nh.iph->tos))))
  803. goto tx_error_icmp;
  804.       mtu = dst_mtu(&rt->u.dst);
  805.       //数据包过长超过MTU,但又是不允许分片的,发送ICMP出错包
  806.       if ((skb->len > mtu) && (skb->nh.iph->frag_off & __constant_htons(IP_DF))) {
  807.              ip_rt_put(rt);
  808.              icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
  809.              IP_VS_DBG_RL("ip_vs_in_icmp(): frag needed\n");
  810.              goto tx_error;
  811.       }
  812.       //让skb可写
  813.       if (!ip_vs_make_skb_writable(&skb, offset))
  814.              goto tx_error_put;
  815.       //skb留出足够的硬件头空间
  816.       if (skb_cow(skb, rt->u.dst.dev->hard_header_len))
  817. goto tx_error_put;
  818.       dst_release(skb->dst);
  819.       skb->dst = &rt->u.dst;
  820.       //修改ICMP包
  821.       ip_vs_nat_icmp(skb, pp, cp, );
  822.       /* Another hack: avoid icmp_send in ip_fragment */
  823.       skb->local_df = ;
  824.  
  825.       //将该包用OUTPUT点的hook_ops进行处理
  826.       /* #define IP_VS_XMIT(skb, rt)                             \
  827.        * do {                                                    \
  828.        *       (skb)->ipvs_property = 1;                       \
  829.        *       (skb)->ip_summed = CHECKSUM_NONE;               \
  830.        *       NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, (skb), NULL, (rt)->u.dst.dev, dst_output);           \
  831.        * } while (0)
  832.        */
  833.       IP_VS_XMIT(skb, rt);
  834.       rc = NF_STOLEN; //表示该skb不用返回到正常的IP栈了
  835.       goto out;
  836. tx_error_icmp:
  837.       dst_link_failure(skb);
  838. tx_error:
  839.       dev_kfree_skb(skb);
  840.       rc = NF_STOLEN;
  841. out:
  842.       return rc;
  843. tx_error_put:
  844.       ip_rt_put(rt);
  845.       goto tx_error;
  846. }
  847. static struct nf_hook_ops ip_vs_post_routing_ops = {
  848.         .hook           = ip_vs_post_routing,
  849.         .owner          = THIS_MODULE,
  850.         .pf             = PF_INET,
  851.         .hooknum        = NF_IP_POST_ROUTING,
  852.         .priority       = NF_IP_PRI_NAT_SRC-, //在源NAT之前进行
  853. };
  854. 这个函数对最后要发出的包进行检查，这个包是经过FORWARD链的，源地址已经被IPVS修改过了，不用再被netfilter进行修改，那么返回NF_STOP.
  855. 如果是IPVS处理过的包,直接跳出POSTROUTING点, 不再继续可能的该点的更低优先级的hook点操作，即不用进行netfilter标准的SNAT操作.
  856. static unsigned int ip_vs_post_routing(unsigned int hooknum, struct sk_buff **pskb, const struct net_device *in,
  857.                                        const struct net_device *out, int (*okfn)(struct sk_buff *))
  858. {
  859.         if (!((*pskb)->ipvs_property)) //如果没被IPVS处理过，继续后续hook点操作
  860.                 return NF_ACCEPT;
  861.         //STOP就不继续后面的低优先级的hook_ops的操作了
  862.         return NF_STOP;
  863. }
  864. [/hook点实现]
  865. [IPVS调度算法]
  866. 均衡调度算法是IPVS实现均衡功能的理论精髓，其他各种东西都只算是程序技巧，现在介绍.
  867. IPVS支持8种静态均衡算法，以下文字直接拷贝自IPVS网站：
  868.  
  869. IPVS在内核中的负载均衡是以连接为粒度的.在HTTP协议（非持久）中，每个对象从WEB服务器上获取都需要建立一个TCP连接，
  870. 同一用户的不同请求会被调度到不同的服务器上，所以这种细粒度的调度在一定程度上可以避免单个用户访问的突发性引起服务器间的负载不平衡.
  871. 在内核中的连接调度算法上，IPVS已实现了以下八种调度算法：
  872.  
  873. 轮叫调度（Round-Robin Scheduling）
  874. 加权轮叫调度（Weighted Round-Robin Scheduling）
  875. 最小连接调度（Least-Connection Scheduling）
  876. 加权最小连接调度（Weighted Least-Connection Scheduling）
  877. 基于局部性的最少链接（Locality-Based Least Connections Scheduling）
  878. 带复制的基于局部性最少链接（Locality-Based Least Connections with Replication Scheduling）
  879. 目标地址散列调度（Destination Hashing Scheduling）
  880. 源地址散列调度（Source Hashing Scheduling）
  881.  
  882. 下面，我们先介绍这八种连接调度算法的工作原理和算法流程，然后会在下面描述怎么用它们.
  883.  
  884. 轮叫调度 :
  885. （Round Robin Scheduling）算法就是以轮叫的方式依次将请求调度不同的服务器，即每次调度执行i = (i + ) mod n，并选出第i台服务器。
  886. 算法的优点是其简洁性，它无需记录当前所有连接的状态，所以它是一种无状态调度。
  887. 在系统实现时，我们引入了一个额外条件，当服务器的权值为零时，表示该服务器不可用而不被调度。
  888. 这样做的目的是将服务器切出服务（如屏蔽服务器故障和系统维护），同时与其他加权算法保持一致。所以，算法要作相应的改动，它的算法流程如下：
  889. 轮叫调度算法流程
  890. 假设有一组服务器S = {S0, S1, …, Sn-}，一个指示变量i表示上一次选择的服务器，W(Si)表示服务器Si的权值。变量 i 被初始化为n-，其中n > 。
  891. j = i;
  892. do {
  893.       j = (j + ) mod n;
  894. ) {
  895.             i = j;
  896.             return Si;
  897.       }
  898. } while (j != i);
  899. return NULL;
  900. 轮叫调度算法假设所有服务器处理性能均相同，不管服务器的当前连接数和响应速度。
  901. 该算法相对简单，不适用于服务器组中处理性能不一的情况，而且当请求服务时间变化比较大时，轮叫调度算法容易导致服务器间的负载不平衡。
  902. 虽然Round-Robin DNS方法也是以轮叫调度的方式将一个域名解析到多个IP地址，但轮叫DNS方法的调度粒度是基于每个域名服务器的，
  903. 域名服务器对域名解析的缓存会妨碍轮叫解析域名生效，这会导致服务器间负载的严重不平衡。
  904. 这里，IPVS轮叫调度算法的粒度是基于每个连接的，同一用户的不同连接都会被调度到不同的服务器上，所以这种细粒度的轮叫调度要比DNS的轮叫调度优越很多.
  905.  
  906. 加权轮叫调度 :
  907. （Weighted Round-Robin Scheduling）算法可以解决服务器间性能不一的情况，它用相应的权值表示服务器的处理性能，服务器的缺省权值为1。
  908. 假设服务器A的权值为1，B的权值为2，则表示服务器B的处理性能是A的两倍。加权轮叫调度算法是按权值的高低和轮叫方式分配请求到各服务器。
  909. 权值高的服务器先收到的连接，权值高的服务器比权值低的服务器处理更多的连接，相同权值的服务器处理相同数目的连接数。加权轮叫调度算法流程如下：
  910. 加权轮叫调度算法流程
  911. 假设有一组服务器S = {S0, S1, …, Sn-}，W(Si)表示服务器Si的权值，一个指示变量i表示上一次选择的服务器，
  912. 指示变量cw表示当前调度的权值，max(S)表示集合S中所有服务器的最大权值，gcd(S)表示集合S中所有服务器权值的最大公约数。
  913. 变量i初始化为-，cw初始化为零。
  914.  
  915. while (true) {
  916.       i = (i + ) mod n;
  917. ) {
  918.             cw = cw - gcd(S);
  919. ) {
  920.                   cw = max(S);
  921. )
  922.                         return NULL;
  923.             }
  924.       }
  925.       if (W(Si) >= cw)
  926.             return Si;
  927. }
  928. 例如，有三个服务器A、B和C分别有权值4、3和2，则在一个调度周期内(mod sum(W(Si)))调度序列为AABABCABC。
  929. 加权轮叫调度算法还是比较简单和高效。当请求的服务时间变化很大，单独的加权轮叫调度算法依然会导致服务器间的负载不平衡。
  930. 从上面的算法流程中，我们可以看出当服务器的权值为零时，该服务器不被被调度；
  931. 当所有服务器的权值为零，即对于任意i有 W(Si)=，则没有任何服务器可用，算法返回NULL，所有的新连接都会被丢掉。
  932. 加权轮叫调度也无需记录当前所有连接的状态，所以它也是一种无状态调度。
  933.  
  934. 最小连接调度 :
  935. （Least-Connection Scheduling）算法是把新的连接请求分配到当前连接数最小的服务器。
  936. 最小连接调度是一种动态调度算法，它通过服务器当前所活跃的连接数来估计服务器的负载情况。
  937. 调度器需要记录各个服务器已建立连接的数目，当一个请求被调度到某台服务器，其连接数加1；当连接中止或超时，其连接数减一。
  938. 在系统实现时，我们也引入当服务器的权值为零时，表示该服务器不可用而不被调度，它的算法流程如下：
  939. 最小连接调度算法流程
  940. 假设有一组服务器S = {S0, S1, ..., Sn-}，W(Si)表示服务器Si的权值，C(Si)表示服务器Si的当前连接数。
  941.  
  942. ; m < n; m++) {
  943. ) {
  944. ; i < n; i++) {
  945. )
  946.                         continue;
  947.                   if (C(Si) < C(Sm))
  948.                         m = i;
  949.             }
  950.             return Sm;
  951.       }
  952. }
  953. return NULL;
  954.  
  955. 当各个服务器有相同的处理性能时，最小连接调度算法能把负载变化大的请求分布平滑到各个服务器上，所有处理时间比较长的请求不可能被发送到同一台服务器上。
  956. 但是，当各个服务器的处理能力不同时，该算法并不理想，因为TCP连接处理请求后会进入TIME_WAIT状态，TCP的TIME_WAIT一般为2分钟，
  957. 此时连接还占用服务器的资源，所以会出现这样情形，性能高的服务器已处理完所收到的连接，连接处于TIME_WAIT状态，
  958. 而性能低的服务器已经忙于处理所收到的连接，还不断地收到新的连接请求。
  959.  
  960. 加权最小连接调度 :
  961. （Weighted Least-Connection Scheduling）算法是最小连接调度的超集，各个服务器用相应的权值表示其处理性能。
  962. 服务器的缺省权值为1，系统管理员可以动态地设置服务器的权值。加权最小连接调度在调度新连接时尽可能使服务器的已建立连接数和其权值成比例。
  963. 加权最小连接调度的算法流程如下：
  964. 加权最小连接调度的算法流程
  965. 假设有一组服务器S = {S0, S1, ..., Sn-}，W(Si)表示服务器Si的权值，C(Si)表示服务器Si的当前连接数。
  966. 所有服务器当前连接数的总和为CSUM = ΣC(Si) (i=, , .. , n-)。当前的新连接请求会被发送服务器Sm，
  967. 当且仅当服务器Sm满足以下条件
  968. (C(Sm) / CSUM)/ W(Sm) = min { (C(Si) / CSUM) / W(Si)} (i=, , . , n-)
  969. 其中W(Si)不为零
  970. 因为CSUM在这一轮查找中是个常数，所以判断条件可以简化为
  971. C(Sm) / W(Sm) = min { C(Si) / W(Si)} (i=, , . , n-)
  972. 其中W(Si)不为零
  973. 因为除法所需的CPU周期比乘法多，且在Linux内核中不允许浮点除法，服务器的权值都大于零，
  974. 所以判断条件C(Sm) / W(Sm) > C(Si) / W(Si) 可以进一步优化为C(Sm)*W(Si) > C(Si)* W(Sm)。
  975. 同时保证服务器的权值为零时，服务器不被调度。所以，算法只要执行以下流程。
  976.  
  977. ; m < n; m++) {
  978. ) {
  979. ; i < n; i++) {
  980.                   if (C(Sm)*W(Si) > C(Si)*W(Sm))
  981.                         m = i;
  982.             }
  983.             return Sm;
  984.       }
  985. }
  986. return NULL;
  987.  
  988. 基于局部性的最少链接调度 :
  989. （Locality-Based Least Connections Scheduling，以下简称为LBLC）算法是针对请求报文的目标IP地址的负载均衡调度，目前主要用于Cache集群系统，
  990. 因为在Cache集群中客户请求报文的目标IP地址是变化的。这里假设任何后端服务器都可以处理任一请求，算法的设计目标是在服务器的负载基本平衡情况下，
  991. 将相同目标IP地址的请求调度到同一台服务器，来提高各台服务器的访问局部性和主存Cache命中率，从而整个集群系统的处理能力。
  992. LBLC调度算法先根据请求的目标IP地址找出该目标IP地址最近使用的服务器，若该服务器是可用的且没有超载，将请求发送到该服务器；
  993. 若服务器不存在，或者该服务器超载且有服务器处于其一半的工作负载，则用“最少链接”的原则选出一个可用的服务器，将请求发送到该服务器。
  994. 该算法的详细流程如下：
  995. LBLC调度算法流程
  996. 假设有一组服务器S = {S0, S1, ..., Sn-}，W(Si)表示服务器Si的权值，C(Si)表示服务器Si的当前连接数。
  997. ServerNode[dest_ip]是一个关联变量，表示目标IP地址所对应的服务器结点，一般来说它是通过Hash表实现的。
  998. WLC(S)表示在集合S中的加权最小连接服务器，即前面的加权最小连接调度。Now为当前系统时间。
  999.  
  1000. if (ServerNode[dest_ip] is NULL) {
  1001.       n = WLC(S);
  1002.       if (n is NULL)
  1003.             return NULL;
  1004.       ServerNode[dest_ip].server = n;
  1005. } else {
  1006.       n = ServerNode[dest_ip].server;
  1007. ))) {
  1008.             n = WLC(S);
  1009.             if (n is NULL)
  1010.                   return NULL;
  1011.             ServerNode[dest_ip].server = n;
  1012.       }
  1013. }
  1014. ServerNode[dest_ip].lastuse = Now;
  1015. return n;
  1016.  
  1017. 此外，对关联变量ServerNode[dest_ip]要进行周期性的垃圾回收（Garbage Collection），将过期的目标IP地址到服务器关联项进行回收。
  1018. 过期的关联项是指哪些当前时间（实现时采用系统时钟节拍数jiffies）减去最近使用时间超过设定过期时间的关联项，系统缺省的设定过期时间为24小时。
  1019.  
  1020. 带复制的基于局部性最少链接调度 :
  1021. （Locality-Based Least Connections with Replication Scheduling，以下简称为LBLCR）算法也是针对目标IP地址的负载均衡，目前主要用于Cache集群系统。
  1022. 它与LBLC算法的不同之处是它要维护从一个目标IP地址到一组服务器的映射，而LBLC算法维护从一个目标IP地址到一台服务器的映射。
  1023. 对于一个“热门”站点的服务请求，一台Cache 服务器可能会忙不过来处理这些请求。
  1024. 这时，LBLC调度算法会从所有的Cache服务器中按“最小连接”原则选出一台Cache服务器，映射该“热门”站点到这台Cache服务器，
  1025. 很快这台Cache服务器也会超载，就会重复上述过程选出新的Cache服务器。
  1026. 这样，可能会导致该“热门”站点的映像会出现在所有的Cache服务器上，降低了Cache服务器的使用效率。
  1027. LBLCR调度算法将“热门”站点映射到一组Cache服务器（服务器集合），当该“热门”站点的请求负载增加时，会增加集合里的Cache服务器，来处理不断增长的负载；
  1028. 当该“热门”站点的请求负载降低时，会减少集合里的Cache服务器数目。
  1029. 这样，该“热门”站点的映像不太可能出现在所有的Cache服务器上，从而提供Cache集群系统的使用效率。
  1030. LBLCR算法先根据请求的目标IP地址找出该目标IP地址对应的服务器组；按“最小连接”原则从该服务器组中选出一台服务器，
  1031. 若服务器没有超载，将请求发送到该服务器；若服务器超载；则按“最小连接”原则从整个集群中选出一台服务器，将该服务器加入到服务器组中，将请求发送到该服务器。同时，当该服务器组有一段时间没有被修改，将最忙的服务器从服务器组中删除，以降低复制的程度。
  1032. LBLCR调度算法的流程如下：
  1033. LBLCR调度算法流程
  1034. 假设有一组服务器S = {S0, S1, ..., Sn-}，W(Si)表示服务器Si的权值，C(Si)表示服务器Si的当前连接数。
  1035. ServerSet[dest_ip]是一个关联变量，表示目标IP地址所对应的服务器集合，一般来说它是通过Hash表实现的。
  1036. WLC(S)表示在集合S中的加权最小连接服务器，即前面的加权最小连接调度；
  1037. WGC(S)表示在集合S中的加权最大连接服务器。
  1038. Now为当前系统时间，lastmod表示集合的最近修改时间，T为对集合进行调整的设定时间。
  1039.  
  1040. if (ServerSet[dest_ip] is NULL) then {
  1041.       n = WLC(S);
  1042.       if (n is NULL)
  1043.             return NULL;
  1044.       add n into ServerSet[dest_ip];
  1045. } else {
  1046.       n = WLC(ServerSet[dest_ip]);
  1047. ))) {
  1048.             n = WLC(S);
  1049.             if (n is NULL)
  1050. return NULL;
  1051.             add n into ServerSet[dest_ip];
  1052.       }  && Now - ServerSet[dest_ip].lastmod > T) {
  1053.             m = WGC(ServerSet[dest_ip]);
  1054.             remove m from ServerSet[dest_ip];
  1055.       }
  1056. }
  1057. ServerSet[dest_ip].lastuse = Now;
  1058. if (ServerSet[dest_ip] changed)
  1059.       ServerSet[dest_ip].lastmod = Now;
  1060. return n;
  1061.  
  1062. 此外，对关联变量ServerSet[dest_ip]也要进行周期性的垃圾回收（Garbage Collection），将过期的目标IP地址到服务器关联项进行回收。
  1063. 过期的关联项是指哪些当前时间（实现时采用系统时钟节拍数jiffies）减去最近使用时间（lastuse）超过设定过期时间的关联项，系统缺省的设定过期时间为24小时。
  1064.  
  1065. 目标地址散列调度 :
  1066. （Destination Hashing Scheduling）算法也是针对目标IP地址的负载均衡，但它是一种静态映射算法，通过一个散列（Hash）函数将一个目标IP地址映射到一台服务器。
  1067. 目标地址散列调度算法先根据请求的目标IP地址，作为散列键（Hash Key）从静态分配的散列表找出对应的服务器，若该服务器是可用的且未超载，
  1068. 将请求发送到该服务器，否则返回空。该算法的流程如下：
  1069.  
  1070. 目标地址散列调度算法流程
  1071. 假设有一组服务器S = {S0, S1, ..., Sn-}，W(Si)表示服务器Si的权值，C(Si)表示服务器Si的当前连接数。
  1072. ServerNode[]是一个有256个桶（Bucket）的Hash表，一般来说服务器的数目会远小于256，当然表的大小也是可以调整的。
  1073. 算法的初始化是将所有服务器顺序、循环地放置到ServerNode表中。若服务器的连接数目大于2倍的权值，则表示服务器已超载。
  1074.  
  1075. n = ServerNode[hashkey(dest_ip)];
  1076. ) || (C(n) > *W(n)))
  1077.       return NULL;
  1078. return n;
  1079.  
  1080. 在实现时，我们采用素数乘法Hash函数，通过乘以素数使得散列键值尽可能地达到较均匀的分布。所采用的素数乘法Hash函数如下：
  1081. 素数乘法Hash函数
  1082. static inline unsigned hashkey(unsigned int dest_ip)
  1083. {
  1084.     return (dest_ip* 2654435761UL) & HASH_TAB_MASK;
  1085. }
  1086. 其中，2654435761UL是2到2^ ()间接近于黄金分割的素数，
  1087. (sqrt() - ) /          = 0.618033989
  1088.  /  = 0.618033987
  1089.  
  1090. 源地址散列调度 :
  1091. （Source Hashing Scheduling）算法正好与目标地址散列调度算法相反，它根据请求的源IP地址，
  1092. 作为散列键（Hash Key）从静态分配的散列表找出对应的服务器，若该服务器是可用的且未超载，将请求发送到该服务器，否则返回空。
  1093. 它采用的散列函数与目标地址散列调度算法的相同。它的算法流程与目标地址散列调度算法的基本相似，
  1094. 除了将请求的目标IP地址换成请求的源IP地址，所以这里不一一叙述。
  1095. 在实际应用中，源地址散列调度和目标地址散列调度可以结合使用在防火墙集群中，它们可以保证整个系统的唯一出入口。
  1096.  
  1097. 下面我们看算法具体实现.
  1098. 每个调度算法的实现就是填写一个ip_vs_scheduler结构，在IPVS服务ip_vs_service结构中指向它即可，这样在连接到达该服务时，通过调度算法选择具体的目的主机。
  1099. 每个算法作为一个单独的内核模块，可由内核配置是否包括该模块。
  1100. 以下以最简单的rr算法来说明，该算法在net/ipv4/ipvs/ip_vs_rr.c中定义。
  1101. static struct ip_vs_scheduler ip_vs_rr_scheduler = {
  1102.       .name =    "rr",                   /* name */
  1103.       .refcnt =   ATOMIC_INIT(),
  1104.       .module =   THIS_MODULE,
  1105.       .init_service =   ip_vs_rr_init_svc,
  1106.       .done_service =   ip_vs_rr_done_svc,
  1107.       .update_service = ip_vs_rr_update_svc,
  1108.       .schedule =   ip_vs_rr_schedule,
  1109. };
  1110. init_service()函数进行算法初始化，在虚拟服务ip_vs_service和调度器绑定时调用 (ip_vs_bind_scheduler()函数)；
  1111. done_service()函数进行算法的清除，在虚拟服务ip_vs_service和调度器解除绑定时调用(ip_vs_unbind_scheduler()函数)；
  1112. update_service()函数在目的服务器变化时调用(如 ip_vs_add_dest(), ip_vs_edit_dest()等函数)；
  1113. static int ip_vs_rr_init_svc(struct ip_vs_service *svc)
  1114. {
  1115.         //其实RR算法也没有什么专用调度数据，sched_data被初始化为目的服务器链表头
  1116.         svc->sched_data = &svc->destinations;
  1117.         ;
  1118. }
  1119. static int ip_vs_rr_done_svc(struct ip_vs_service *svc)
  1120. {
  1121.         ; //没什么可释放的
  1122. }
  1123. static int ip_vs_rr_update_svc(struct ip_vs_service *svc)
  1124. {
  1125.         svc->sched_data = &svc->destinations; //sched_data重新指向服务器链表头
  1126.         ;
  1127. }
  1128. static struct ip_vs_dest * ip_vs_rr_schedule(struct ip_vs_service *svc, const struct sk_buff *skb)
  1129. {
  1130.       struct list_head *p, *q;
  1131.       struct ip_vs_dest *dest;
  1132.  
  1133.       write_lock(&svc->sched_lock);
  1134.       //p实际就是实际目的服务器的链表中的某一个节点
  1135.       //sched_data保存的是上一次调度时用到的节点
  1136.       p = (struct list_head *)svc->sched_data;
  1137.       p = p->next;
  1138.       q = p;
  1139.       do {
  1140.             /* skip list head */
  1141.             if (q == &svc->destinations) {
  1142.                   q = q->next;
  1143.                   continue;
  1144.             }
  1145.  
  1146.             dest = list_entry(q, struct ip_vs_dest, n_list);
  1147.             //只要当前链表目的服务器不是超载而且该服务器权重不为0，就返回该节点
  1148. )
  1149.                   /* HIT */
  1150.                   goto out;
  1151.  
  1152.             q = q->next;
  1153.       } while (q != p);
  1154.       write_unlock(&svc->sched_lock);
  1155.       return NULL;
  1156. out:
  1157.       //保存要使用的节点到sched_data，下次调度时就会取下一个节点，实现轮询
  1158.       svc->sched_data = q;
  1159.       write_unlock(&svc->sched_lock);
  1160.       return dest;
  1161. }
  1162. rr模块初始花函数是
  1163. static int __init ip_vs_rr_init(void)
  1164. {
  1165.         INIT_LIST_HEAD(&ip_vs_rr_scheduler.n_list); //初始化连表
  1166.  
  1167.         //注册调度其中就是把调度结构连接到一个全局连表中
  1168.         //list_add(&scheduler->n_list, &ip_vs_schedulers);
  1169.         //查找时通过name字段，所以name字段不能为空
  1170.         return register_ip_vs_scheduler(&ip_vs_rr_scheduler);
  1171. }
  1172. [/IPVS调度算法]
  1173. [协议实现]
  1174. 我们假定是tcp协议
  1175. struct ip_vs_protocol ip_vs_protocol_tcp = {
  1176.         .name =                 "TCP",
  1177.         .protocol =              IPPROTO_TCP,
  1178.         .dont_defrag =           ,
  1179.         .appcnt =                ATOMIC_INIT(),
  1180.         .init =                    ip_vs_tcp_init,
  1181.         .exit =                   ip_vs_tcp_exit,
  1182.         .register_app =           tcp_register_app,
  1183.         .unregister_app =        tcp_unregister_app,
  1184.         .conn_schedule =        tcp_conn_schedule,
  1185.         .conn_in_get =           tcp_conn_in_get,
  1186.         .conn_out_get =         tcp_conn_out_get,
  1187.         .snat_handler =          tcp_snat_handler,
  1188.         .dnat_handler =          tcp_dnat_handler,
  1189.         .csum_check =           tcp_csum_check,
  1190.         .state_name =           tcp_state_name,
  1191.         .state_transition =       tcp_state_transition,
  1192.         .app_conn_bind =        tcp_app_conn_bind,
  1193.         .debug_packet =         ip_vs_tcpudp_debug_packet,
  1194.         .timeout_change =       tcp_timeout_change,
  1195.         .set_state_timeout =    tcp_set_state_timeout,
  1196. };
  1197. 我们一个一个看实现.
  1198. static void ip_vs_tcp_init(struct ip_vs_protocol *pp)
  1199. {
  1200.         IP_VS_INIT_HASH_TABLE(tcp_apps);
  1201.         pp->timeout_table = tcp_timeouts;
  1202. }
  1203. IPVS定义的超时,和netfilter类似,不过比netfilter的超时少得多,而且这些值不是通过/proc调整,而是通过ipvsadm命令来调整
  1204. ] = {
  1205.         [IP_VS_TCP_S_NONE]              =       *HZ,
  1206.         [IP_VS_TCP_S_ESTABLISHED]       =       **HZ,
  1207.         [IP_VS_TCP_S_SYN_SENT]          =       **HZ,
  1208.         [IP_VS_TCP_S_SYN_RECV]          =       **HZ,
  1209.         [IP_VS_TCP_S_FIN_WAIT]          =       **HZ,
  1210.         [IP_VS_TCP_S_TIME_WAIT]         =       **HZ,
  1211.         [IP_VS_TCP_S_CLOSE]             =       *HZ,
  1212.         [IP_VS_TCP_S_CLOSE_WAIT]        =       *HZ,
  1213.         [IP_VS_TCP_S_LAST_ACK]          =       *HZ,
  1214.         [IP_VS_TCP_S_LISTEN]            =       **HZ,
  1215.         [IP_VS_TCP_S_SYNACK]            =       *HZ,
  1216.         [IP_VS_TCP_S_LAST]              =       *HZ,
  1217. };
  1218. 是个啥也不作的空函数,只是让函数指针不为空
  1219. static void ip_vs_tcp_exit(struct ip_vs_protocol *pp)
  1220. {}
  1221. 登记TCP应用(多连接)协议
  1222. static int tcp_register_app(struct ip_vs_app *inc)
  1223. {
  1224.         struct ip_vs_app *i;
  1225.         __u16 hash, port = inc->port;
  1226.         ;
  1227.         //根据端口计算一个HASH值
  1228.         hash = tcp_app_hashkey(port);
  1229.  
  1230.         spin_lock_bh(&tcp_app_lock);
  1231.         list_for_each_entry(i, &tcp_apps[hash], p_list) {
  1232.                 if (i->port == port) {
  1233.                         ret = -EEXIST;
  1234.                         goto out;
  1235.                 }
  1236.         }
  1237.         list_add(&inc->p_list, &tcp_apps[hash]);// 将新应用协议添加到HASH表中
  1238.         atomic_inc(&ip_vs_protocol_tcp.appcnt);// 增加应用协议计数器
  1239. out:
  1240.         spin_unlock_bh(&tcp_app_lock);
  1241.         return ret;
  1242. }
  1243. static void tcp_unregister_app(struct ip_vs_app *inc)
  1244. {
  1245.         spin_lock_bh(&tcp_app_lock);
  1246.         atomic_dec(&ip_vs_protocol_tcp.appcnt);
  1247.         list_del(&inc->p_list);
  1248.         spin_unlock_bh(&tcp_app_lock);
  1249. }
  1250. 连接调度的目的是找到一个合适的目的服务器，生成新连接。该函数在ip_vs_in()函数中调用
  1251. static int tcp_conn_schedule(struct sk_buff *skb, struct ip_vs_protocol *pp, int *verdict, struct ip_vs_conn **cpp)
  1252. {
  1253.       struct ip_vs_service *svc;
  1254.       struct tcphdr _tcph, *th;
  1255.       //取出tcp头
  1256.       th = skb_header_pointer(skb, skb->nh.iph->ihl*, sizeof(_tcph), &_tcph);
  1257.       if (th == NULL) {
  1258.             *verdict = NF_DROP;
  1259. ;
  1260.       }
  1261.       //如果是syn包且有虚拟服务器
  1262.       if (th->syn && (svc = ip_vs_service_get(skb->nfmark, skb->nh.iph->protocol, skb->nh.iph->daddr, th->dest))) {
  1263.              if (ip_vs_todrop()) { //是否这虚拟服务器本身已经负载严重
  1264.                   ip_vs_service_put(svc);
  1265.                   *verdict = NF_DROP;
  1266. ;
  1267.              }
  1268.              *cpp = ip_vs_schedule(svc, skb); //建立ipvs连接
  1269.              if (!*cpp) { //没有成功
  1270.                   *verdict = ip_vs_leave(svc, skb, pp); //后续处理，更新统计包，发送icmp不可达数据包等.
  1271. ;
  1272.              }
  1273.              ip_vs_service_put(svc);
  1274.       }
  1275. ;
  1276. }
  1277. struct ip_vs_conn * ip_vs_schedule(struct ip_vs_service *svc, const struct sk_buff *skb)
  1278. {
  1279.       struct ip_vs_conn *cp = NULL;
  1280.       struct iphdr *iph = skb->nh.iph;
  1281.       struct ip_vs_dest *dest;
  1282.       __u16 _ports[], *pptr;
  1283.  
  1284.       //TCP/UDP头指针,[0]为源端口,[1]为目的端口
  1285.       pptr = skb_header_pointer(skb, iph->ihl*, sizeof(_ports), _ports);
  1286.       if (pptr == NULL)
  1287.             return NULL;
  1288.  
  1289.       if (svc->flags & IP_VS_SVC_F_PERSISTENT) //处理持久服务器
  1290.             return ip_vs_sched_persist(svc, skb, pptr);
  1291. ] != svc->port) {
  1292.             if (!svc->port)
  1293.                   IP_VS_ERR("Schedule: port zero only supported in persistent services, check your ipvs configuration\n");
  1294.             return NULL;
  1295.       }
  1296.       //调用调度器的调度函数获取一个目的服务器指针，调度器的调度函数看上面IPVS调度算法.
  1297.       dest = svc->scheduler->schedule(svc, skb);
  1298.       if (dest == NULL) {
  1299.             IP_VS_DBG(, "Schedule: no dest found.\n");
  1300.             return NULL;
  1301.       }
  1302.       //新建一个IPVS连接
  1303.       cp = ip_vs_conn_new(iph->protocol, iph->saddr, pptr[], iph->daddr, pptr[], dest->addr, dest->port ? dest->port : pptr[], , dest);
  1304.       if (cp == NULL)
  1305.             return NULL;
  1306.  
  1307.       //更新服务和连接相关计数器统计
  1308.       ip_vs_conn_stats(cp, svc);
  1309.       return cp;
  1310. }
  1311. 持久调度函数,用在多连接协议处理中将子连接与主连接挂钩
  1312. ])
  1313. {
  1314.       struct ip_vs_conn *cp = NULL;
  1315.       struct iphdr *iph = skb->nh.iph;
  1316.       struct ip_vs_dest *dest;
  1317.       struct ip_vs_conn *ct;
  1318.       __u16  dport;    /* destination port to forward */
  1319.       __u32  snet;
  1320.       //取出网络部分地址
  1321.       snet = iph->saddr & svc->netmask;
  1322.  
  1323.       //数据包目的端口是服务端口,正向请求子连接
  1324. ] == svc->port) {
  1325.             //查找连接模板, 专门区分了是否是FTP端口,所以程序在此没有扩展性
  1326.             //源地址用的是网络部分地址,源端口用0
  1327.             //所谓模板,应该就是指主连接,相当于netfilter跟踪子连接时端口部分不进行限制
  1328.             //不过这里IPVS跟踪子连接作的没有netfilter好
  1329.  
  1330.             if (svc->port != FTPPORT)
  1331.                   ct = ip_vs_ct_in_get(iph->protocol, snet, , iph->daddr, ports[]);
  1332.             else
  1333.                   ct = ip_vs_ct_in_get(iph->protocol, snet, , iph->daddr, );
  1334.  
  1335.             if (!ct || !ip_vs_check_template(ct)) { //找不到连接模板或者连接模板的目的服务器不可用
  1336.                   //使用调度器调度找一个服务器
  1337.                   dest = svc->scheduler->schedule(svc, skb);
  1338.                   if (dest == NULL) {
  1339.                        IP_VS_DBG(, "p-schedule: no dest found.\n");
  1340.                        return NULL;
  1341.                   }
  1342.                   //建立一个新连接模板,如果是FTP服务,目的端口不确定
  1343.                   if (svc->port != FTPPORT)
  1344.                         ct = ip_vs_conn_new(iph->protocol, snet, , iph->daddr, ports[], dest->addr, dest->port,
  1345.                                     IP_VS_CONN_F_TEMPLATE, dest);
  1346.                   else
  1347.                         ct = ip_vs_conn_new(iph->protocol, snet, , iph->daddr, , dest->addr, ,
  1348.                                                     IP_VS_CONN_F_TEMPLATE, dest);
  1349.  
  1350.             } else { //找到连接模板,目的服务器用连接的目的服务器
  1351.                   dest = ct->dest;
  1352.             }
  1353.             dport = dest->port; //目的端口为目的服务器端口
  1354.      } else { //数据包目的端口不是服务端口,可能是反向请求的子连接
  1355.  
  1356.             if (svc->fwmark)//找相关连接模板,此时用的端口都是0
  1357.                   ct = ip_vs_ct_in_get(IPPROTO_IP, snet, , htonl(svc->fwmark), );
  1358.             else
  1359.                   ct = ip_vs_ct_in_get(iph->protocol, snet, , iph->daddr, );
  1360.  
  1361. if (!ct || !ip_vs_check_template(ct)) {
  1362. if (svc->port)   return NULL;                  dest = svc->scheduler->schedule(svc, skb);
  1363.                   if (dest == NULL) {
  1364.                         IP_VS_DBG(, "p-schedule: no dest found.\n");
  1365. return NULL;
  1366.                   }
  1367.                   if (svc->fwmark)
  1368.                         ct = ip_vs_conn_new(IPPROTO_IP, snet, , htonl(svc->fwmark), , dest->addr, ,
  1369.                                                     IP_VS_CONN_F_TEMPLATE, dest);
  1370.                   else
  1371.                         ct = ip_vs_conn_new(iph->protocol, snet, , iph->daddr, , dest->addr, ,
  1372.                                                     IP_VS_CONN_F_TEMPLATE, dest);
  1373.                   if (ct == NULL)
  1374.                         return NULL;
  1375.  
  1376.                   ct->timeout = svc->timeout;
  1377.             } else { //找到连接模板,目的服务器用连接的目的服务器
  1378.                   dest = ct->dest;
  1379.             }
  1380.             dport = ports[];
  1381.       }
  1382.       //建立一个新连接
  1383.       cp = ip_vs_conn_new(iph->protocol, iph->saddr, ports[], iph->daddr, ports[], dest->addr, dport, , dest);
  1384.       if (cp == NULL) {
  1385.             ip_vs_conn_put(ct);
  1386.             return NULL;
  1387.       }
  1388.       //将连接模板作为新连接的主连接
  1389.       ip_vs_control_add(cp, ct);
  1390.       //get的时候增加了连接模板ct的引用计数,现在减少
  1391.       ip_vs_conn_put(ct);
  1392.       //更新连接服务计数器统计
  1393.       ip_vs_conn_stats(cp, svc);
  1394.       return cp;
  1395. }
  1396. 获取连接模板的函数,没有s_port为0的特殊处理,在查找固定连接和模板连接时使用
  1397. struct ip_vs_conn *ip_vs_ct_in_get (int protocol, __u32 s_addr, __u16 s_port, __u32 d_addr, __u16 d_port)
  1398. {
  1399.       unsigned hash;
  1400.       struct ip_vs_conn *cp;
  1401.       //计算HASH值是用源的三元组来计算：IP协议、源地址、源端口
  1402.       hash = ip_vs_conn_hashkey(protocol, s_addr, s_port);
  1403.       ct_read_lock(hash);
  1404.       list_for_each_entry(cp, &ip_vs_conn_tab[hash], c_list) {
  1405.             if (s_addr==cp->caddr && s_port==cp->cport && d_port==cp->vport && d_addr==cp->vaddr &&
  1406.                     cp->flags & IP_VS_CONN_F_TEMPLATE && protocol==cp->protocol) {
  1407.                  /* HIT */
  1408.                  atomic_inc(&cp->refcnt);
  1409.                  goto out;            }
  1410.       }
  1411.       cp = NULL;
  1412. out:
  1413.       ct_read_unlock(hash);
  1414.       return cp;
  1415. }
  1416. 建立一个新连接
  1417. struct ip_vs_conn * ip_vs_conn_new(int proto, __u32 caddr, __u16 cport, __u32 vaddr, __u16 vport,
  1418.                __u32 daddr, __u16 dport, unsigned flags, struct ip_vs_dest *dest)
  1419. {
  1420.       struct ip_vs_conn *cp;
  1421.       struct ip_vs_protocol *pp = ip_vs_proto_get(proto);
  1422.       //从cache中分配连接
  1423.       cp = kmem_cache_alloc(ip_vs_conn_cachep, GFP_ATOMIC);
  1424.       if (cp == NULL) {
  1425.             IP_VS_ERR_RL("ip_vs_conn_new: no memory available.\n");
  1426.             return NULL;
  1427.       }
  1428.       memset(cp, , sizeof(*cp));
  1429.       INIT_LIST_HEAD(&cp->c_list);
  1430.       init_timer(&cp->timer);
  1431.       cp->timer.data     = (unsigned long)cp;
  1432.       cp->timer.function = ip_vs_conn_expire; //连接超时函数
  1433.       cp->protocol       = proto;
  1434.       cp->caddr          = caddr;
  1435.       cp->cport          = cport;
  1436.       cp->vaddr          = vaddr;
  1437.       cp->vport          = vport;
  1438.       cp->daddr          = daddr;
  1439.       cp->dport          = dport;
  1440.       cp->flags          = flags;
  1441.       spin_lock_init(&cp->lock);
  1442.  
  1443.       atomic_set(&cp->refcnt, );// 引用初始值为1
  1444.       atomic_set(&cp->n_control, );// 子连接数置0
  1445.       atomic_set(&cp->in_pkts, );
  1446.  
  1447.       atomic_inc(&ip_vs_conn_count);
  1448.  
  1449.       if (flags & IP_VS_CONN_F_NO_CPORT)
  1450.             atomic_inc(&ip_vs_conn_no_cport_cnt);
  1451.       ip_vs_bind_dest(cp, dest); // 将连接和目的服务器进行绑定
  1452.       cp->state = ; //连接初始状态为0
  1453.       cp->timeout = *HZ;  // 缺省超时为3秒
  1454.  
  1455.       ip_vs_bind_xmit(cp);// 绑定连接的数据包的发送方法
  1456.  
  1457.       //绑定协议应用,其实目前只有TCP的FTP一种,所以用了unlikely
  1458.       if (unlikely(pp && atomic_read(&pp->appcnt)))
  1459.             //调用协议的app_conn_bind成员函数,对TCP协议来说就是tcp_app_conn_bind()函数
  1460.             //只在NAT模式下有效
  1461.             //检查该端口是否属于某多连接应用协议,是的话连接上绑定该协议处理, 相当于netfilter的连接的helper
  1462.            ip_vs_bind_app(cp, pp);//实现 return pp->app_conn_bind(cp);
  1463.  
  1464.       //将该连接节点加入到IPVS连接表中
  1465.       ip_vs_conn_hash(cp);
  1466.       return cp;
  1467. }
  1468. 绑定连接目的服务器
  1469. static inline void ip_vs_bind_dest(struct ip_vs_conn *cp, struct ip_vs_dest *dest)
  1470. {
  1471.       if (!dest)
  1472.             return;
  1473.       atomic_inc(&dest->refcnt);
  1474.       //根据服务器情况设置连接标志,主要是用来确定连接数据包的发送方法
  1475.       cp->flags |= atomic_read(&dest->conn_flags);
  1476.       cp->dest = dest;
  1477.  
  1478.       if (!(cp->flags & IP_VS_CONN_F_TEMPLATE)) {
  1479.             /* It is a normal connection, so increase the inactive connection counter because it is in TCP SYNRECV
  1480.             state (inactive) or other protocol inacive state */
  1481.             atomic_inc(&dest->inactconns); // 增加目的服务器的不活动连接计数,目前还属于不活动连接
  1482.       } else {
  1483. /* It is a persistent connection/template, so increase the peristent connection counter */
  1484.             atomic_inc(&dest->persistconns); // 如果是永久连接或模板,增加目的服务器的永久连接计数       }
  1485.       //检查目的服务器的连接数是否超载了
  1486.  && ip_vs_dest_totalconns(dest) >= dest->u_threshold)
  1487.             dest->flags |= IP_VS_DEST_F_OVERLOAD;
  1488. }
  1489. 绑定发送方法，参看下面发送方法实现
  1490. static inline void ip_vs_bind_xmit(struct ip_vs_conn *cp)
  1491. {
  1492.         //#define IP_VS_FWD_METHOD(cp)  (cp->flags & IP_VS_CONN_F_FWD_MASK)
  1493.         switch (IP_VS_FWD_METHOD(cp)) {
  1494.         case IP_VS_CONN_F_MASQ:
  1495.                 cp->packet_xmit = ip_vs_nat_xmit; // NAT发送
  1496.                 break;
  1497.  
  1498.         case IP_VS_CONN_F_TUNNEL:
  1499.                 cp->packet_xmit = ip_vs_tunnel_xmit;// TUNNEL发送
  1500.                 break;
  1501.  
  1502.         case IP_VS_CONN_F_DROUTE:
  1503.                 cp->packet_xmit = ip_vs_dr_xmit;// DR发送
  1504.                 break;
  1505.  
  1506.         case IP_VS_CONN_F_LOCALNODE:
  1507.                 cp->packet_xmit = ip_vs_null_xmit;// 本地包
  1508.                 break;
  1509.  
  1510.         case IP_VS_CONN_F_BYPASS:
  1511.                 cp->packet_xmit = ip_vs_bypass_xmit;// 旁路发送
  1512.                 break;
  1513.         }
  1514. }
  1515.  
  1516. 要实现面向连接的处理的基本功能就是根据数据包内容查找连接,IPVS区分每个连接的关键数据和netfilter一样是五元组，
  1517. 为IP协议、源地址、源端口、目的地址和目的端口，不过没定义方向的概念，所以在IPVS中请求方向和回应方向要用不同的查找函数处理，
  1518. 由于IPVS是在INPUT点处理请求， 在FORWARD点处理回应包，不会在同一个点同时处理请求包和回应包，因此可以没有方向的概念。
  1519.  
  1520. 在ip_vs_out()函数中正向调用,在ip_vs_out_icmp()函数中反向调用
  1521. static struct ip_vs_conn * tcp_conn_in_get(const struct sk_buff *skb, struct ip_vs_protocol *pp,
  1522.                                                const struct iphdr *iph, unsigned int proto_off, int inverse)
  1523. {
  1524.       __u16 _ports[], *pptr;
  1525.       //TCP/UDP头指针,[0]为源端口,[1]为目的端口
  1526.       pptr = skb_header_pointer(skb, proto_off, sizeof(_ports), _ports);
  1527.       if (pptr == NULL)
  1528.             return NULL;
  1529.       if (likely(!inverse)) { //正向还是反向，在绝大多数情况下是按正向查找连接
  1530. ], iph->daddr, pptr[]);
  1531.       } else {
  1532. ], iph->saddr, pptr[]);
  1533.       }
  1534. }
  1535. struct ip_vs_conn *ip_vs_conn_in_get(int protocol, __u32 s_addr, __u16 s_port, __u32 d_addr, __u16 d_port)
  1536. {
  1537.       struct ip_vs_conn *cp;
  1538.       cp = __ip_vs_conn_in_get(protocol, s_addr, s_port, d_addr, d_port);
  1539.  
  1540.       //没有找到，源端口设为0，再次查找
  1541.       if (!cp && atomic_read(&ip_vs_conn_no_cport_cnt))
  1542.             cp = __ip_vs_conn_in_get(protocol, s_addr, , d_addr, d_port);
  1543.       return cp;
  1544. }
  1545. static inline struct ip_vs_conn *__ip_vs_conn_in_get(int protocol, __u32 s_addr, __u16 s_port, __u32 d_addr, __u16 d_port)
  1546. {
  1547.       unsigned hash;
  1548.       struct ip_vs_conn *cp;
  1549.  
  1550.       //入(请求)方向计算HASH值是用源的三元组来计算：IP协议、源地址、源端口
  1551.       hash = ip_vs_conn_hashkey(protocol, s_addr, s_port);
  1552.       ct_read_lock(hash);
  1553.       list_for_each_entry(cp, &ip_vs_conn_tab[hash], c_list) {
  1554. //caddr，cport是连接记录的客户端的地址和端口
  1555. if (s_addr == cp->caddr && s_port == cp->cport && d_port == cp->vport && d_addr == cp->vaddr &&
  1556. //连接中的客户端端口为0的情况
  1557.                     ((!s_port) ^ (!(cp->flags & IP_VS_CONN_F_NO_CPORT))) && protocol == cp->protocol) {
  1558.                   /* HIT */
  1559.                   atomic_inc(&cp->refcnt); //增加连接引用
  1560.                   ct_read_unlock(hash);
  1561. return cp;
  1562.             }
  1563.       }
  1564.       ct_read_unlock(hash);
  1565.       return NULL;
  1566. }
  1567. 与in几乎一样
  1568. static struct ip_vs_conn *tcp_conn_out_get(const struct sk_buff *skb, struct ip_vs_protocol *pp,
  1569.                                              const struct iphdr *iph, unsigned int proto_off, int inverse)
  1570. {
  1571.       __u16 _ports[], *pptr;
  1572.  
  1573.       pptr = skb_header_pointer(skb, proto_off, sizeof(_ports), _ports);
  1574.       if (pptr == NULL)
  1575. return NULL;
  1576.       if (likely(!inverse)) {
  1577. ], iph->daddr, pptr[]);
  1578.       } else {
  1579. ], iph->saddr, pptr[]);
  1580.       }
  1581. }
  1582. struct ip_vs_conn *ip_vs_conn_out_get(int protocol, __u32 s_addr, __u16 s_port, __u32 d_addr, __u16 d_port)
  1583. {
  1584.       unsigned hash;
  1585.       struct ip_vs_conn *cp, *ret=NULL;
  1586.  
  1587.       //出方向计算HASH值是用目的三元组来计算：IP协议、目的地址和目的端口，
  1588.       //这样计算结果和入方向的计算值是相同的
  1589.       hash = ip_vs_conn_hashkey(protocol, d_addr, d_port);
  1590.       ct_read_lock(hash);
  1591.       list_for_each_entry(cp, &ip_vs_conn_tab[hash], c_list) {
  1592.             if (d_addr == cp->caddr && d_port == cp->cport && s_port == cp->dport && s_addr == cp->daddr &&                                                                            protocol == cp->protocol) {
  1593.                   /* HIT */
  1594.                   atomic_inc(&cp->refcnt);
  1595.                   ret = cp;
  1596.                   break;
  1597.             }
  1598.       }
  1599.       ct_read_unlock(hash);
  1600.       return ret;
  1601. }
  1602. 该函数完成对协议部分数据进行源NAT操作,对TCP来说,NAT部分的数据就是源端口
  1603. static int tcp_snat_handler(struct sk_buff **pskb, struct ip_vs_protocol *pp, struct ip_vs_conn *cp)
  1604. {
  1605.       struct tcphdr *tcph;
  1606.       unsigned ;
  1607.  
  1608.       //NAT操作skb必须是可写的
  1609.       if (!ip_vs_make_skb_writable(pskb, tcphoff+sizeof(*tcph)))
  1610. ;
  1611. if (unlikely(cp->app != NULL)) {// 如果是多连接协议,进行应用协议内容部分数据的修改            //目前只支持FTP协议,对FTP作NAT时,需要修改PORT命令或227回应内容中的地址端口信息
  1612.             if (pp->csum_check && !pp->csum_check(*pskb, pp))
  1613. ;
  1614.  
  1615. /* Call application helper if needed */
  1616.             if (!ip_vs_app_pkt_out(cp, pskb))
  1617. ;
  1618.       }
  1619.       tcph = (void *)(*pskb)->nh.iph + tcphoff;
  1620.       tcph->source = cp->vport;// 修改当前TCP源端口
  1621.  
  1622.       if (!cp->app) {
  1623.             //如果只修改了源端口一个参数,就值需要用差值法快速计算新的TCP校验和
  1624.             tcp_fast_csum_update(tcph, cp->daddr, cp->vaddr, cp->dport, cp->vport);
  1625.             if ((*pskb)->ip_summed == CHECKSUM_HW)
  1626.                   (*pskb)->ip_summed = CHECKSUM_NONE;
  1627.       } else {
  1628. // 如果修改了协议内容部分数据,需要根据全部数据重新计算TCP校验和
  1629.             tcph->check = ;
  1630.             (*pskb)->csum = skb_checksum(*pskb, tcphoff, (*pskb)->len - tcphoff, );
  1631.             tcph->check = csum_tcpudp_magic(cp->vaddr, cp->caddr, (*pskb)->len - tcphoff, cp->protocol, (*pskb)->csum);
  1632.       }
  1633. ;}
  1634. 应用协议修改输出方向的应用层数据
  1635. int ip_vs_app_pkt_out(struct ip_vs_conn *cp, struct sk_buff **pskb)
  1636. {
  1637.         struct ip_vs_app *app;
  1638.  
  1639.         //检查连接是否和应用绑定
  1640.         if ((app = cp->app) == NULL)
  1641.                 ;
  1642.  
  1643.         //TCP协议另外单独处理
  1644.         if (cp->protocol == IPPROTO_TCP)
  1645.                 return app_tcp_pkt_out(cp, pskb, app);
  1646.  
  1647.         //非TCP协议调用应用协议的pkt_out()函数，我们只看tcp协议
  1648.         if (app->pkt_out == NULL)
  1649.                 ;
  1650.  
  1651.         return app->pkt_out(app, cp, pskb, NULL);
  1652. }
  1653. 处理TCP应用发出方向的数据包
  1654. static inline int app_tcp_pkt_out(struct ip_vs_conn *cp, struct sk_buff **pskb, struct ip_vs_app *app)
  1655. {
  1656.       int diff;
  1657.       //计算偏移值
  1658.       unsigned ;
  1659.       struct tcphdr *th;
  1660.       __u32 seq;
  1661.  
  1662.       //首先要让数据包可写
  1663.       if (!ip_vs_make_skb_writable(pskb, tcp_offset + sizeof(*th)))
  1664. ;
  1665.  
  1666.       th = (struct tcphdr *)((*pskb)->nh.raw + tcp_offset);
  1667.       seq = ntohl(th->seq);//当前的序列号
  1668.  
  1669.       if (cp->flags & IP_VS_CONN_F_OUT_SEQ)
  1670.             vs_fix_seq(&cp->out_seq, th); //修改发出方向序列号
  1671. if (cp->flags & IP_VS_CONN_F_IN_SEQ)            vs_fix_ack_seq(&cp->in_seq, th); //修改进入方向序列号
  1672. ;
  1673. //调用应用协议的pkt_out()函数，看下面处理多连接协议      if (!app->pkt_out(app, cp, pskb, &diff))
  1674. ;
  1675. )//数据长度发生变化,再次修改发出方向的序列号            vs_seq_update(cp, &cp->out_seq, IP_VS_CONN_F_OUT_SEQ, seq, diff);
  1676.  
  1677. ;
  1678. }
  1679. 该函数完成对协议部分数据进行目的NAT操作,对TCP来说,NAT部分的数据就是目的端口
  1680. static int tcp_dnat_handler(struct sk_buff **pskb, struct ip_vs_protocol *pp, struct ip_vs_conn *cp)
  1681. {
  1682.       struct tcphdr *tcph;
  1683.       unsigned ;
  1684.  
  1685.       /* csum_check requires unshared skb */
  1686.       if (!ip_vs_make_skb_writable(pskb, tcphoff+sizeof(*tcph)))
  1687. ;
  1688. if (unlikely(cp->app != NULL)) {// 如果是多连接协议,进行应用协议内容部分数据的修改
  1689.            // 目前只支持FTP协议,对FTP作NAT时,需要修改PORT命令或227回应内容中的地址端口信息
  1690.            if (pp->csum_check && !pp->csum_check(*pskb, pp))
  1691. ;              
  1692.  
  1693.            if (!ip_vs_app_pkt_in(cp, pskb))
  1694. ;
  1695.       }
  1696.       tcph = (void *)(*pskb)->nh.iph + tcphoff;
  1697.       tcph->dest = cp->dport;// 修改当前TCP目的端口
  1698.  
  1699.       if (!cp->app) {
  1700.             /* Only port and addr are changed, do fast csum update */
  1701.             tcp_fast_csum_update(tcph, cp->vaddr, cp->daddr, cp->vport, cp->dport);
  1702.             if ((*pskb)->ip_summed == CHECKSUM_HW)
  1703.                   (*pskb)->ip_summed = CHECKSUM_NONE;
  1704.       } else {
  1705.             /* full checksum calculation */
  1706.             tcph->check = ;
  1707.             (*pskb)->csum = skb_checksum(*pskb, tcphoff, (*pskb)->len - tcphoff, );
  1708.             tcph->check = csum_tcpudp_magic(cp->caddr, cp->daddr, (*pskb)->len - tcphoff, cp->protocol, (*pskb)->csum);
  1709.             (*pskb)->ip_summed = CHECKSUM_UNNECESSARY;
  1710.       }
  1711. ;
  1712. }
  1713. int ip_vs_app_pkt_in(struct ip_vs_conn *cp, struct sk_buff **pskb)
  1714. {
  1715.         struct ip_vs_app *app;
  1716.         //检查连接是否和应用绑定
  1717.         if ((app = cp->app) == NULL)
  1718.                 ;
  1719.  
  1720.         if (cp->protocol == IPPROTO_TCP)//TCP协议另外单独处理
  1721.                 return app_tcp_pkt_in(cp, pskb, app);
  1722.  
  1723.         if (app->pkt_in == NULL)
  1724.                 ;
  1725.  
  1726.         return app->pkt_in(app, cp, pskb, NULL);
  1727. }
  1728. static inline int app_tcp_pkt_in(struct ip_vs_conn *cp, struct sk_buff **pskb, struct ip_vs_app *app)
  1729. {
  1730.       int diff;
  1731.       unsigned ;
  1732.       struct tcphdr *th;
  1733.       __u32 seq;
  1734.       //首先要让数据包可写
  1735.       if (!ip_vs_make_skb_writable(pskb, tcp_offset + sizeof(*th)))
  1736. ;
  1737.  
  1738.       th = (struct tcphdr *)((*pskb)->nh.raw + tcp_offset);
  1739.       seq = ntohl(th->seq);
  1740.  
  1741.       if (cp->flags & IP_VS_CONN_F_IN_SEQ)//修改进入方向序列号
  1742.             vs_fix_seq(&cp->in_seq, th);
  1743. if (cp->flags & IP_VS_CONN_F_OUT_SEQ)//修改发出方向序列号            vs_fix_ack_seq(&cp->out_seq, th);
  1744. ;
  1745.  
  1746.       if (!app->pkt_in(app, cp, pskb, &diff))//调用应用协议的pkt_in()函数，参看下面处理多连接协议
  1747. ;
  1748. )//数据长度发生变化,再次修改输入方向的序列号            vs_seq_update(cp, &cp->in_seq, IP_VS_CONN_F_IN_SEQ, seq, diff);
  1749.  
  1750. ;
  1751. }
  1752. 计算IP协议中的校验和,对于TCP,UDP头中都有校验和参数,TCP中的校验和是必须的,而UDP的校验和可以不用计算。
  1753. 该函数用的都是linux内核提供标准的校验和计算函数
  1754. static int tcp_csum_check(struct sk_buff *skb, struct ip_vs_protocol *pp)
  1755. {
  1756.       unsigned ;
  1757.       switch (skb->ip_summed) {
  1758.       case CHECKSUM_NONE:
  1759.             skb->csum = skb_checksum(skb, tcphoff, skb->len - tcphoff, );
  1760. case CHECKSUM_HW:
  1761.            if (csum_tcpudp_magic(skb->nh.iph->saddr, skb->nh.iph->daddr, skb->len - tcphoff, skb->nh.iph->protocol, skb->csum)) {
  1762.                  IP_VS_DBG_RL_PKT(, pp, skb, , "Failed checksum for");
  1763. ;
  1764.            }
  1765.             break;
  1766.       default:
  1767.             /* CHECKSUM_UNNECESSARY */
  1768.             break;
  1769.       }
  1770. ; //checksum correct
  1771. }
  1772. 该函数返回协议状态名称字符串
  1773. static const char * tcp_state_name(int state)
  1774. {
  1775.         if (state >= IP_VS_TCP_S_LAST)
  1776.                 return "ERR!";
  1777.         return tcp_state_name_table[state] ? tcp_state_name_table[state] : "?";
  1778. }
  1779. ] = {
  1780.         [IP_VS_TCP_S_NONE]              =       "NONE",
  1781.         [IP_VS_TCP_S_ESTABLISHED]       =       "ESTABLISHED",
  1782.         [IP_VS_TCP_S_SYN_SENT]          =       "SYN_SENT",
  1783.         [IP_VS_TCP_S_SYN_RECV]          =       "SYN_RECV",
  1784.         [IP_VS_TCP_S_FIN_WAIT]          =       "FIN_WAIT",
  1785.         [IP_VS_TCP_S_TIME_WAIT]         =       "TIME_WAIT",
  1786.         [IP_VS_TCP_S_CLOSE]             =       "CLOSE",
  1787.         [IP_VS_TCP_S_CLOSE_WAIT]        =       "CLOSE_WAIT",
  1788.         [IP_VS_TCP_S_LAST_ACK]          =       "LAST_ACK",
  1789.         [IP_VS_TCP_S_LISTEN]            =       "LISTEN",
  1790.         [IP_VS_TCP_S_SYNACK]            =       "SYNACK",
  1791.         [IP_VS_TCP_S_LAST]              =       "BUG!",
  1792. };
  1793. IPVS的TCP状态转换和netfilter是类似的，在NAT模式下几乎就是相同的，在TUNNEL和DR模式下是半连接的状态转换。
  1794. 在每个数据包进出IPVS时都会调用
  1795. static int tcp_state_transition(struct ip_vs_conn *cp, int direction, const struct sk_buff *skb, struct ip_vs_protocol *pp)
  1796. {
  1797.         struct tcphdr _tcph, *th;
  1798.  
  1799.         th = skb_header_pointer(skb, skb->nh.iph->ihl*, sizeof(_tcph), &_tcph);
  1800.         if (th == NULL)
  1801.                 ;
  1802.  
  1803.         spin_lock(&cp->lock);
  1804.         set_tcp_state(pp, cp, direction, th);// 重新设置连接状态
  1805.         spin_unlock(&cp->lock);
  1806.         ;
  1807. }
  1808. static inline void set_tcp_state(struct ip_vs_protocol *pp, struct ip_vs_conn *cp, int direction, struct tcphdr *th)
  1809. {
  1810.       int state_idx;
  1811.       int new_state = IP_VS_TCP_S_CLOSE;// 缺省新状态,连接关闭
  1812.       int state_off = tcp_state_off[direction];// 各方向的状态偏移值,确定是用转换表中的哪个数组
  1813.  
  1814.       if (cp->flags & IP_VS_CONN_F_NOOUTPUT) {// 修正一下半连接时的控制参数
  1815.             if (state_off == TCP_DIR_OUTPUT)
  1816.                   cp->flags &= ~IP_VS_CONN_F_NOOUTPUT;
  1817. else
  1818.                   state_off = TCP_DIR_INPUT_ONLY;
  1819.       }
  1820. ) {// 根据TCP标志返回状态索引号
  1821. , "tcp_state_idx=%d!!!\n", state_idx);
  1822.             goto tcp_state_out;
  1823.       }
  1824.       // 从状态转换表中查新状态
  1825.       new_state = tcp_state_table[state_off + state_idx].next_state[cp->state];
  1826. tcp_state_out:
  1827.       if (new_state != cp->state) {//状态迁移了
  1828.             struct ip_vs_dest *dest = cp->dest;
  1829.             if (dest) {// 连接的目的服务器存在
  1830.                   //如果连接是以前是活动的,新状态不是TCP连接建立好时, 将连接标志改为非活动连接,修改计数器
  1831.                   if (!(cp->flags & IP_VS_CONN_F_INACTIVE) && (new_state != IP_VS_TCP_S_ESTABLISHED)) {
  1832.                         atomic_dec(&dest->activeconns);
  1833.                         atomic_inc(&dest->inactconns);
  1834.                         cp->flags |= IP_VS_CONN_F_INACTIVE;
  1835.                         //如果连接以前是不活动的,新状态是TCP连接建立好时, 将连接标志改为活动连接,修改计数器
  1836.                   } else if ((cp->flags & IP_VS_CONN_F_INACTIVE) && (new_state == IP_VS_TCP_S_ESTABLISHED)) {
  1837.                         atomic_inc(&dest->activeconns);
  1838.                         atomic_dec(&dest->inactconns);
  1839.                         cp->flags &= ~IP_VS_CONN_F_INACTIVE;
  1840.                   }
  1841.             }
  1842.       }
  1843.       cp->timeout = pp->timeout_table[cp->state = new_state];// 更新连接超时
  1844. }
  1845. static inline int tcp_state_idx(struct tcphdr *th)
  1846. {
  1847.         if (th->rst)
  1848.                 ;
  1849.         if (th->syn)
  1850.                 ;
  1851.         if (th->fin)
  1852.                 ;
  1853.         if (th->ack)
  1854.                 ;
  1855.         ;
  1856. }
  1857. #define TCP_DIR_INPUT            0
  1858. #define TCP_DIR_OUTPUT          4
  1859. #define TCP_DIR_INPUT_ONLY      8
  1860. static const int tcp_state_off[IP_VS_DIR_LAST] = {
  1861.         [IP_VS_DIR_INPUT]                =       TCP_DIR_INPUT,
  1862.         [IP_VS_DIR_OUTPUT]              =       TCP_DIR_OUTPUT,
  1863.         [IP_VS_DIR_INPUT_ONLY]          =       TCP_DIR_INPUT_ONLY,
  1864. };
  1865. IPVS的TCP状态转换表:
  1866. static struct tcp_states_t tcp_states [] = {
  1867. /* INPUT */
  1868. /*        sNO, sES, sSS, sSR, sFW, sTW, sCL, sCW, sLA, sLI, sSA */
  1869. /*syn*/ {{sSR, sES, sES, sSR, sSR, sSR, sSR, sSR, sSR, sSR, sSR }},
  1870. /*fin*/ {{sCL, sCW, sSS, sTW, sTW, sTW, sCL, sCW, sLA, sLI, sTW }},
  1871. /*ack*/ {{sCL, sES, sSS, sES, sFW, sTW, sCL, sCW, sCL, sLI, sES }},
  1872. /*rst*/ {{sCL, sCL, sCL, sSR, sCL, sCL, sCL, sCL, sLA, sLI, sSR }},
  1873. /* OUTPUT */
  1874. /*        sNO, sES, sSS, sSR, sFW, sTW, sCL, sCW, sLA, sLI, sSA */
  1875. /*syn*/ {{sSS, sES, sSS, sSR, sSS, sSS, sSS, sSS, sSS, sLI, sSR }},
  1876. /*fin*/ {{sTW, sFW, sSS, sTW, sFW, sTW, sCL, sTW, sLA, sLI, sTW }},
  1877. /*ack*/ {{sES, sES, sSS, sES, sFW, sTW, sCL, sCW, sLA, sES, sES }},
  1878. /*rst*/ {{sCL, sCL, sSS, sCL, sCL, sTW, sCL, sCL, sCL, sCL, sCL }},
  1879. /* INPUT-ONLY */
  1880. /*        sNO, sES, sSS, sSR, sFW, sTW, sCL, sCW, sLA, sLI, sSA */
  1881. /*syn*/ {{sSR, sES, sES, sSR, sSR, sSR, sSR, sSR, sSR, sSR, sSR }},
  1882. /*fin*/ {{sCL, sFW, sSS, sTW, sFW, sTW, sCL, sCW, sLA, sLI, sTW }},
  1883. /*ack*/ {{sCL, sES, sSS, sES, sFW, sTW, sCL, sCW, sCL, sLI, sES }},
  1884. /*rst*/ {{sCL, sCL, sCL, sSR, sCL, sCL, sCL, sCL, sLA, sLI, sCL }},
  1885. };
  1886. 这个状态转换表的前两个数组和2.4内核中的TCP转换表类似,少了“none”类型标志，不过从表中数据看是INPUT对应REPLY方向,OUTPUT对应ORIGINAL方向,
  1887. 这个有点怪,好象是IPVS站在就是服务器本身的角度看状态,而不是象netfilter是站在中间人的角度, 数组的查看方法和netfilter相同:
  1888. 对于三次握手, 刚开始连接状态是sNO,来了个SYN包后, IPVS就觉得自己是服务器,状态就变为sSR而不是sSS,
  1889. 如果是NAT模式SYNACK返回通过IPVS时,状态仍然是sSR, 等第3个ACK来时转为sES。
  1890.  
  1891. IPVS还有另一个状态转换表，相对更严格一些，也安全一些：
  1892. static struct tcp_states_t tcp_states_dos [] = {
  1893. /* INPUT */
  1894. /*        sNO, sES, sSS, sSR, sFW, sTW, sCL, sCW, sLA, sLI, sSA */
  1895. /*syn*/ {{sSR, sES, sES, sSR, sSR, sSR, sSR, sSR, sSR, sSR, sSA }},
  1896. /*fin*/ {{sCL, sCW, sSS, sTW, sTW, sTW, sCL, sCW, sLA, sLI, sSA }},
  1897. /*ack*/ {{sCL, sES, sSS, sSR, sFW, sTW, sCL, sCW, sCL, sLI, sSA }},
  1898. /*rst*/ {{sCL, sCL, sCL, sSR, sCL, sCL, sCL, sCL, sLA, sLI, sCL }},
  1899. /* OUTPUT */
  1900. /*        sNO, sES, sSS, sSR, sFW, sTW, sCL, sCW, sLA, sLI, sSA */
  1901. /*syn*/ {{sSS, sES, sSS, sSA, sSS, sSS, sSS, sSS, sSS, sLI, sSA }},
  1902. /*fin*/ {{sTW, sFW, sSS, sTW, sFW, sTW, sCL, sTW, sLA, sLI, sTW }},
  1903. /*ack*/ {{sES, sES, sSS, sES, sFW, sTW, sCL, sCW, sLA, sES, sES }},
  1904. /*rst*/ {{sCL, sCL, sSS, sCL, sCL, sTW, sCL, sCL, sCL, sCL, sCL }},
  1905. /* INPUT-ONLY */
  1906. /*        sNO, sES, sSS, sSR, sFW, sTW, sCL, sCW, sLA, sLI, sSA */
  1907. /*syn*/ {{sSA, sES, sES, sSR, sSA, sSA, sSA, sSA, sSA, sSA, sSA }},
  1908. /*fin*/ {{sCL, sFW, sSS, sTW, sFW, sTW, sCL, sCW, sLA, sLI, sTW }},
  1909. /*ack*/ {{sCL, sES, sSS, sES, sFW, sTW, sCL, sCW, sCL, sLI, sES }},
  1910. /*rst*/ {{sCL, sCL, sCL, sSR, sCL, sCL, sCL, sCL, sLA, sLI, sCL }},
  1911. };
  1912. 本函数实现将多连接应用协议处理模块和IPVS连接进行绑定
  1913. static int tcp_app_conn_bind(struct ip_vs_conn *cp)
  1914. {
  1915.       int hash;
  1916.       struct ip_vs_app *inc;
  1917. ;
  1918.       // 只在NAT模式下处理
  1919.       if (IP_VS_FWD_METHOD(cp) != IP_VS_CONN_F_MASQ)
  1920. ;
  1921. // 计算一下目的端口的HASH      hash = tcp_app_hashkey(cp->vport);
  1922.       spin_lock(&tcp_app_lock);
  1923.       list_for_each_entry(inc, &tcp_apps[hash], p_list) {
  1924.             if (inc->port == cp->vport) {// 根据端口找到相应的应用模块
  1925.                   if (unlikely(!ip_vs_app_inc_get(inc)))// 增加模块引用计数
  1926.                         break;
  1927.                   spin_unlock(&tcp_app_lock);
  1928.                   cp->app = inc;// 将连接的应用模块指针指向改应用模块
  1929.                   if (inc->init_conn)
  1930.                         result = inc->init_conn(inc, cp);//初始化应用模块
  1931.                   goto out;
  1932.             }
  1933.       }
  1934.       spin_unlock(&tcp_app_lock);
  1935. out:
  1936.       return result;
  1937. }
  1938. timeout_change函数用来变化协议连接的超时，具体就是TCP有两个超时表，用哪个表由本函数决定：
  1939. flags参数是由ipvsadm配置时传递来的。
  1940. static void tcp_timeout_change(struct ip_vs_protocol *pp, int flags)
  1941. {
  1942.         );           /* secure_tcp */
  1943.  
  1944.         /*
  1945.         ** FIXME: change secure_tcp to independent sysctl var
  1946.         ** or make it per-service or per-app because it is valid
  1947.         ** for most if not for all of the applications. Something
  1948.         ** like "capabilities" (flags) for each object.
  1949.         */
  1950.         tcp_state_table = (on ? tcp_states_dos : tcp_states);
  1951. }
  1952. 该函数在ipvsadm设置相关命令时调用
  1953. static int tcp_set_state_timeout(struct ip_vs_protocol *pp, char *sname, int to)
  1954. {
  1955.         return ip_vs_set_state_timeout(pp->timeout_table, IP_VS_TCP_S_LAST, tcp_state_name_table, sname, to);
  1956. }
  1957. int ip_vs_set_state_timeout(int *table, int num, char **names, char *name, int to)
  1958. {
  1959.         int i;
  1960.         if (!table || !name || !to)
  1961.                 return -EINVAL;
  1962.         //根据状态名称查找在状态在超时表中的位置然后修改超时时间，超时参数to单位为秒
  1963.         ; i < num; i++) {
  1964.                 if (strcmp(names[i], name))
  1965.                         continue;
  1966.                 table[i] = to * HZ;
  1967.                 ;
  1968.         }
  1969.         return -ENOENT;
  1970. }
  1971. [/协议实现]
  1972. [发送方法实现]
  1973. NAT发送只发送请求方向的数据,因此是进行目的NAT
  1974. int ip_vs_nat_xmit(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp)
  1975. {
  1976.       struct rtable *rt;              /* Route to the other host */
  1977.       int mtu;
  1978.       struct iphdr *iph = skb->nh.iph;
  1979.       //如果连接标志了客户端端口为0,将当前skb中的端口填给连接
  1980.       if (unlikely(cp->flags & IP_VS_CONN_F_NO_CPORT)) {
  1981.             __u16 _pt, *p;
  1982.             p = skb_header_pointer(skb, iph->ihl*, sizeof(_pt), &_pt);
  1983.             if (p == NULL)
  1984.                   goto tx_error;
  1985.  
  1986.             ip_vs_conn_fill_cport(cp, *p);// *p是源端口
  1987.             IP_VS_DBG(, "filled cport=%d\n", ntohs(*p));
  1988.       }
  1989.       //查找路由,找不到的话发ICMP出错包
  1990.       if (!(rt = __ip_vs_get_out_rt(cp, RT_TOS(iph->tos))))
  1991.             goto tx_error_icmp;
  1992.  
  1993.       //检查路由发出网卡的MTU,如果包长超过MTU又有DF标志,发送ICMP错误信息,而不进行分片操作
  1994.       mtu = dst_mtu(&rt->u.dst);
  1995.       if ((skb->len > mtu) && (iph->frag_off&__constant_htons(IP_DF))) {
  1996.             ip_rt_put(rt);
  1997.             icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
  1998.             IP_VS_DBG_RL_PKT(, pp, skb, , "ip_vs_nat_xmit(): frag needed for");
  1999.             goto tx_error;
  2000.       }
  2001.       //让skb包的IP头部分是可写的
  2002.       if (!ip_vs_make_skb_writable(&skb, sizeof(struct iphdr)))
  2003.             goto tx_error_put;
  2004.       //扩充skb头部空间以容纳硬件MAC头数据      if (skb_cow(skb, rt->u.dst.dev->hard_header_len))
  2005.             goto tx_error_put;
  2006. //释放skb当前的路由cache      dst_release(skb->dst);
  2007.       skb->dst = &rt->u.dst;
  2008.  
  2009.       //对上层协议(TCP/UDP...)进行目的NAT,因为要发送给实际的目的服务器，看上面协议实现
  2010.       if (pp->dnat_handler && !pp->dnat_handler(&skb, pp, cp))
  2011.             goto tx_error;
  2012. //修改目的地址为真实目的服务器地址      skb->nh.iph->daddr = cp->daddr;
  2013.       ip_send_check(skb->nh.iph);//计算IP头校验和
  2014.  
  2015.       /* Another hack: avoid icmp_send in ip_fragment */
  2016.       skb->local_df = ;
  2017.       //发送数据包,实际还是HOOK住netfilter的OUTPUT点,受OUTPUT规则限制
  2018.       IP_VS_XMIT(skb, rt);
  2019.       return NF_STOLEN;
  2020. tx_error_icmp:
  2021.       dst_link_failure(skb);
  2022. tx_error:
  2023.       kfree_skb(skb);
  2024.       return NF_STOLEN;
  2025. tx_error_put:
  2026.       ip_rt_put(rt);
  2027.       goto tx_error;
  2028. }
  2029. TUNNEL发送是把原来的IP部分再加在一个IPIP协议头后发出去,新头的目的IP是真实目的服务器,源IP是真实客户端IP,
  2030. 该包是可以路由的,服务器的回应包将直接路由回去而不经过IPVS.
  2031. int ip_vs_tunnel_xmit(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp)
  2032. {
  2033.       struct rtable *rt;                      /* Route to the other host */
  2034.       struct net_device *tdev;                /* Device to other host */
  2035.       struct iphdr  *old_iph = skb->nh.iph;
  2036.       u8     tos = old_iph->tos;
  2037.       __be16 df = old_iph->frag_off;
  2038.       struct iphdr  *iph;                     /* Our new IP header */
  2039.       int    max_headroom;                    /* The extra header space needed */
  2040.       int    mtu;
  2041.  
  2042.       //只包装IP包，其他协议如ARP，IPX等不管
  2043.       if (skb->protocol != __constant_htons(ETH_P_IP)) {
  2044.             IP_VS_DBG_RL("ip_vs_tunnel_xmit(): protocol error, ETH_P_IP: %d, skb protocol: %d\n", __constant_htons(ETH_P_IP), skb->protocol);
  2045.             goto tx_error;
  2046.       }
  2047.       //根据连接信息找外出的路由cache
  2048.       if (!(rt = __ip_vs_get_out_rt(cp, RT_TOS(tos))))
  2049.             goto tx_error_icmp;
  2050.       //数据包发出网卡
  2051.       tdev = rt->u.dst.dev;
  2052.  
  2053.       //检查路径的MTU
  2054.       mtu = dst_mtu(&rt->u.dst) - sizeof(struct iphdr);
  2055. ) {
  2056.             ip_rt_put(rt);
  2057.             IP_VS_DBG_RL("ip_vs_tunnel_xmit(): mtu less than 68\n");
  2058.             goto tx_error;
  2059.       }
  2060.       //更新路由的MTU
  2061.       if (skb->dst)
  2062.             skb->dst->ops->update_pmtu(skb->dst, mtu);
  2063.             df |= (old_iph->frag_off & __constant_htons(IP_DF));
  2064.       //检查don't fragement标志
  2065.       if ((old_iph->frag_off & __constant_htons(IP_DF)) && mtu < ntohs(old_iph->tot_len)) {
  2066.             icmp_send(skb, ICMP_DEST_UNREACH,ICMP_FRAG_NEEDED, htonl(mtu));
  2067.             ip_rt_put(rt);
  2068.             IP_VS_DBG_RL("ip_vs_tunnel_xmit(): frag needed\n");
  2069.             goto tx_error;
  2070.       }
  2071.       //#define LL_RESERVED_SPACE(dev) (((dev)->hard_header_len&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  2072.       //计算需要添加的IP头的最大长度
  2073.       max_headroom = LL_RESERVED_SPACE(tdev) + sizeof(struct iphdr);
  2074.  
  2075.       if (skb_headroom(skb) < max_headroom || skb_cloned(skb) || skb_shared(skb)) {
  2076.             //重新分配一个skb包,该skb头部足够大可容纳外部IP头空间
  2077.             //分配失败则不发送该包了
  2078.             struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
  2079.             if (!new_skb) {
  2080.                   ip_rt_put(rt);
  2081.                   kfree_skb(skb);
  2082.                   IP_VS_ERR_RL("ip_vs_tunnel_xmit(): no memory\n");
  2083.                   return NF_STOLEN;
  2084.             }
  2085.             kfree_skb(skb);//将原来的skb释放掉
  2086.             skb = new_skb;//将skb指向新包
  2087.             old_iph = skb->nh.iph;//更新ip头指针
  2088.       }
  2089.       //skb->h是传输层头,现在要新加个IP头,原来的IP头就升级为传输层头
  2090.       skb->h.raw = (void *) old_iph;
  2091.  
  2092.       //计算老IP头的校验和
  2093.       ip_send_check(old_iph);
  2094.  
  2095.       //skb的data指针前移出IP头长度作为新IP头的起点
  2096.       skb->nh.raw = skb_push(skb, sizeof(struct iphdr));
  2097.       memset(&(IPCB(skb)->opt), , sizeof(IPCB(skb)->opt));
  2098.  
  2099.       //更新路由cache
  2100.       dst_release(skb->dst);
  2101.       skb->dst = &rt->u.dst;
  2102.  
  2103.       //填写新IP头部信息
  2104.       iph                     =       skb->nh.iph;
  2105.       iph->version            =       ;
  2106.       iph->ihl                =       ;
  2107.       iph->frag_off           =       df;
  2108.       iph->protocol           =       IPPROTO_IPIP;//协议设置为IPIP, 值为4
  2109.       iph->tos                =       tos;
  2110.       iph->daddr              =       rt->rt_dst;
  2111.       iph->saddr              =       rt->rt_src;
  2112.       iph->ttl                =       old_iph->ttl;
  2113.       iph->tot_len            =       htons(skb->len);
  2114.       ip_select_ident(iph, &rt->u.dst, NULL); //设置IP头中的ID值
  2115.       ip_send_check(iph);//计算IP头校验和
  2116.  
  2117.       /* Another hack: avoid icmp_send in ip_fragment */
  2118.       skb->local_df = ;
  2119.       //发送新的skb包
  2120.       IP_VS_XMIT(skb, rt);
  2121.       return NF_STOLEN;
  2122. tx_error_icmp:
  2123.       dst_link_failure(skb);
  2124. tx_error:
  2125.       kfree_skb(skb);
  2126.       return NF_STOLEN;
  2127. }
  2128. DR发送是将原来的skb包中的目的MAC地址修改为目的服务器的MAC地址后直接发出,因此是不能路由的,IPVS均衡设备和目的服务器物理上必须在同一个二层子网。
  2129. 在DR模式下，IPVS和服务器都配置了相同的对外服务的VIP，服务器也配了自己的真实IP，不过服务器上配VIP的网卡属性中的NOARP信息是打开的，
  2130. 就是在该网卡上不响应ARP信息，但可以接收到达该VIP的数据包，这样外面请求包先是到IPVS均衡器，因为IPVS的VIP是响应ARP的，
  2131. 然后根据调度找一台服务器，用服务器的真实IP来确定路由，然后直接把包发出来，这时包中所有数据都没修改，
  2132. 因为目的服务器上VIP地址符合包中的目的地址，因此是可以接收该包的。
  2133. int ip_vs_dr_xmit(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp)
  2134. {
  2135.       struct rtable *rt;                      /* Route to the other host */
  2136.       struct iphdr  *iph = skb->nh.iph;
  2137.       int    mtu;
  2138.       //根据连接指定的目的服务器找路由
  2139.       if (!(rt = __ip_vs_get_out_rt(cp, RT_TOS(iph->tos))))
  2140.             goto tx_error_icmp;
  2141.  
  2142.       //检查MTU
  2143.       mtu = dst_mtu(&rt->u.dst);
  2144.       if ((iph->frag_off&__constant_htons(IP_DF)) && skb->len > mtu) {
  2145.             icmp_send(skb, ICMP_DEST_UNREACH,ICMP_FRAG_NEEDED, htonl(mtu));
  2146.             ip_rt_put(rt);
  2147.             IP_VS_DBG_RL("ip_vs_dr_xmit(): frag needed\n");
  2148.             goto tx_error;
  2149.       }
  2150.  
  2151.       //防止skb包是共用的,还被其他地方使用
  2152.       if (unlikely((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)) {
  2153.             ip_rt_put(rt);
  2154.             return NF_STOLEN;
  2155.       }
  2156.       ip_send_check(skb->nh.iph);//重新计算IP头校验和
  2157.       dst_release(skb->dst);//释放原来的路由
  2158.       skb->dst = &rt->u.dst;
  2159.  
  2160.       skb->local_df = ;
  2161.       IP_VS_XMIT(skb, rt);//直接发出了
  2162.       return NF_STOLEN;
  2163. tx_error_icmp:
  2164.       dst_link_failure(skb);
  2165. tx_error:
  2166.       kfree_skb(skb);
  2167.       return NF_STOLEN;
  2168. }
  2169. 什么都没作
  2170. int ip_vs_null_xmit(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp)
  2171. {
  2172.         /* we do not touch skb and do not need pskb ptr */
  2173.         return NF_ACCEPT;
  2174. }
  2175. 旁路模式,实际数据包不是给IPVS均衡器自己的,由IPVS进行转发
  2176. int ip_vs_bypass_xmit(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp)
  2177. {
  2178.       struct rtable *rt;                      /* Route to the other host */
  2179.       struct iphdr  *iph = skb->nh.iph;
  2180.       u8     tos = iph->tos;
  2181.       int    mtu;
  2182.       struct flowi fl = {//用当前IP包的目的地址作为查路由的key
  2183.          .oif = ,
  2184.          .nl_u = {
  2185.                  .ip4_u = {
  2186.                          .daddr = iph->daddr,
  2187.                          .saddr = ,
  2188.                          .tos = RT_TOS(tos), } },
  2189.       };
  2190.       //查找当前数据包的目的IP地址对应的路由,而不是IPVS连接的信息找路由
  2191.       if (ip_route_output_key(&rt, &fl)) {
  2192.             IP_VS_DBG_RL("ip_vs_bypass_xmit(): ip_route_output error, dest: %u.%u.%u.%u\n", NIPQUAD(iph->daddr));
  2193.             goto tx_error_icmp;
  2194.       }
  2195.       //MTU检查
  2196.       mtu = dst_mtu(&rt->u.dst);
  2197.       if ((skb->len > mtu) && (iph->frag_off & __constant_htons(IP_DF))) {
  2198.             ip_rt_put(rt);
  2199.             icmp_send(skb, ICMP_DEST_UNREACH,ICMP_FRAG_NEEDED, htonl(mtu));
  2200.             IP_VS_DBG_RL("ip_vs_bypass_xmit(): frag needed\n");
  2201.             goto tx_error;
  2202.       }
  2203.       //防止skb包是共用的,还被其他地方使用
  2204.       if (unlikely((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)) {
  2205.             ip_rt_put(rt);
  2206.             return NF_STOLEN;
  2207.       }
  2208.       //计算IP头校验和
  2209.       ip_send_check(skb->nh.iph);
  2210.       //释放老路由,更新路由
  2211.       dst_release(skb->dst);
  2212.       skb->dst = &rt->u.dst;
  2213.  
  2214.       /* Another hack: avoid icmp_send in ip_fragment */
  2215.       skb->local_df = ;
  2216.       IP_VS_XMIT(skb, rt);//发送
  2217.       return NF_STOLEN;
  2218. tx_error_icmp:
  2219.       dst_link_failure(skb);
  2220. tx_error:
  2221.       kfree_skb(skb);
  2222.       return NF_STOLEN;
  2223. }
  2224. [/发送方法实现]
  2225. [处理多连接协议]
  2226. IPVS的应用是针对象FTP等的多连接协议处理的，由于多连接协议的特殊性，任何以连接为基础进行处理的模块如IPVS，netfilter等都必须对这些协议特别处理，
  2227. 不过IPVS相对没有netfilter那么完善，目前也仅仅支持FTP协议，而netfilter已经可以支持FTP、 TFTP、IRC、AMANDA、MMS、SIP、H.323等多种多连接协议。
  2228.  
  2229. IPVS应用也是模块化的，不过其实现有点特别，对于每一个应用协议，会定义一个静态的struct ip_vs_app结构作为模板，以后登记该协议时，
  2230. 对应的应用指针并不是直接指向这个静态结构，而是新分配一个struct ip_vs_app结构，结构中的struct ip_vs_app指针指向这个静态结构，
  2231. 然后把新分配的这个结构分别挂接到静态struct ip_vs_app结构的具体实现链表和 IP协议的应用HASH链表中进行使用，这种实现方法和netfilter完全不同。
  2232.  
  2233. IPVS应用一些共享的处理函数在net/ipv4/ipvs/ip_vs_app.c中定义,其他各协议相关处理分别由各自文件处理,如net/ipv4/ipvs/ip_vs_ftp.c.
  2234.  
  2235. FTP协议应用结构模板
  2236. static struct ip_vs_app ip_vs_ftp = {
  2237.         .name =         "ftp",
  2238.         .type =         IP_VS_APP_TYPE_FTP,
  2239.         .protocol =     IPPROTO_TCP,
  2240.         .module =       THIS_MODULE,
  2241.         .incs_list =    LIST_HEAD_INIT(ip_vs_ftp.incs_list),
  2242.         .init_conn =    ip_vs_ftp_init_conn,
  2243.         .done_conn =    ip_vs_ftp_done_conn,
  2244.         .bind_conn =    NULL,
  2245.         .unbind_conn =  NULL,
  2246.         .pkt_out =      ip_vs_ftp_out,
  2247.         .pkt_in =       ip_vs_ftp_in,
  2248. };
  2249. //初始化和释放什么也没作
  2250. static int ip_vs_ftp_init_conn(struct ip_vs_app *app, struct ip_vs_conn *cp)
  2251. {
  2252.         ;
  2253. }
  2254. static int ip_vs_ftp_done_conn(struct ip_vs_app *app, struct ip_vs_conn *cp)
  2255. {
  2256.         ;
  2257. }
  2258. 发出方向的数据是FTP服务器发出的, 和子连接相关的回应为227类型,建立一个被动模式的子连接
  2259. static int ip_vs_ftp_out(struct ip_vs_app *app, struct ip_vs_conn *cp, struct sk_buff **pskb, int *diff)
  2260. {
  2261.       struct iphdr *iph;
  2262.       struct tcphdr *th;
  2263.       char *data, *data_limit;
  2264.       char *start, *end;
  2265.       __u32 from;
  2266.       __u16 port;
  2267.       struct ip_vs_conn *n_cp;
  2268. ];           /* xxx.xxx.xxx.xxx,ppp,ppp\000 */
  2269.       unsigned buf_len;
  2270.       int ret;
  2271.  
  2272.       *diff = ;
  2273.       //发子连接信息数据时主连接必然是TCP连接建立好状态,否则就出错
  2274.       if (cp->state != IP_VS_TCP_S_ESTABLISHED)
  2275. ;
  2276.       //让数据包可写
  2277.       if (!ip_vs_make_skb_writable(pskb, (*pskb)->len))
  2278. ;
  2279.       //子连接必须是被动模式的
  2280.       if (cp->app_data == &ip_vs_ftp_pasv) {
  2281.             //数据定位
  2282.             iph = (*pskb)->nh.iph;
  2283.             th = (]);
  2284.             data = ();
  2285.             data_limit = (*pskb)->tail;
  2286.  
  2287.             //#define SERVER_STRING "227 Entering Passive Mode ("
  2288.             //查找"227 "回应中的地址端口信息，from和port返回的是网路字节序
  2289. , )
  2290. ;
  2291.  
  2292.             //查找发出方向的连接
  2293. );
  2294.             if (!n_cp) {//正常情况下是找不到的
  2295.                   //新建子连接, 注意各地址端口参数的位置
  2296. , cp->vaddr, port, from, port, IP_VS_CONN_F_NO_CPORT, cp->dest);
  2297.                   if (!n_cp)
  2298. ;
  2299.                   //将子连接和主连接联系起来
  2300.                   ip_vs_control_add(n_cp, cp);
  2301.             }
  2302.             //新地址端口用连接的虚拟地址和端口
  2303.             //需要修改数据包中的数据
  2304.             from = n_cp->vaddr;
  2305.             port = n_cp->vport;
  2306.             //修改后的地址端口信息
  2307.             sprintf(buf,, (port>>)&);
  2308.             buf_len = strlen(buf);
  2309.  
  2310.             //检查数据长度差异
  2311.             *diff = buf_len - (end-start);
  2312.  
  2313. ) {//长度相同的话直接覆盖就行了
  2314.                   memcpy(start, buf, buf_len);
  2315.                   ret = ;
  2316.             } else {//修改数据
  2317.                   ret = !ip_vs_skb_replace(*pskb, GFP_ATOMIC, start, end-start, buf, buf_len);
  2318.             }
  2319.             cp->app_data = NULL;
  2320.             //连接状态设为监听
  2321.             ip_vs_tcp_conn_listen(n_cp);
  2322.             ip_vs_conn_put(n_cp);
  2323.             return ret;
  2324.        }
  2325. ;
  2326. }
  2327. 将skb包中某段数据更改为新的数据,是一个通用函数,可供应用协议修改协议数据的函数调用
  2328. int ip_vs_skb_replace(struct sk_buff *skb, gfp_t pri, char *o_buf, int o_len, char *n_buf, int n_len)
  2329. {
  2330.        struct iphdr *iph;
  2331.        int diff;
  2332.        int o_offset;
  2333.        int o_left;
  2334.  
  2335.        //新数据和老数据的长度差,这影响序列号和确认号
  2336.        diff = n_len - o_len;
  2337.        //老数据在数据包中的偏移
  2338.        o_offset = o_buf - (char *)skb->data;
  2339.        /* The length of left data after o_buf+o_len in the skb data */
  2340.        o_left = skb->len - (o_offset + o_len);//老数据左边的第一个数据
  2341.  
  2342. ) {//新长度不大于老长度,把原来老数据右边的数据移过来
  2343.              memmove(o_buf + n_len, o_buf + o_len, o_left);
  2344.              memcpy(o_buf, n_buf, n_len);
  2345.              skb_trim(skb, skb->len + diff);//减少数据包的长度
  2346.        } else if (diff <= skb_tailroom(skb)) {
  2347.              //新长度大于老长度,但skb包后面的空闲区可以容纳下新数据
  2348.              //扩展数据包长
  2349.              skb_put(skb, diff);
  2350.              memmove(o_buf + n_len, o_buf + o_len, o_left);
  2351.              memcpy(o_buf, n_buf, n_len);
  2352.        } else {
  2353.              //新长度大于老长度,但skb包后面的空闲区也容纳不下新数据
  2354.              //需要重新扩展skb大小
  2355.              if (pskb_expand_head(skb, skb_headroom(skb), diff, pri))
  2356.                    return -ENOMEM;
  2357.  
  2358.              skb_put(skb, diff);
  2359.              memmove(skb->data + o_offset + n_len, skb->data + o_offset + o_len, o_left);
  2360.              memcpy(skb->data + o_offset, n_buf, n_len);
  2361.        }
  2362.        iph = skb->nh.iph;
  2363.        iph->tot_len = htons(skb->len);
  2364. ;
  2365. }
  2366. void ip_vs_tcp_conn_listen(struct ip_vs_conn *cp)
  2367. {
  2368.         spin_lock(&cp->lock);
  2369.         cp->state = IP_VS_TCP_S_LISTEN;//连接状态为监听
  2370.         cp->timeout = ip_vs_protocol_tcp.timeout_table[IP_VS_TCP_S_LISTEN];//连接超时为监听状态的超时
  2371.         spin_unlock(&cp->lock);
  2372. }
  2373. static int ip_vs_ftp_get_addrport(char *data, char *data_limit, const char *pattern, size_t plen, char term,
  2374.                                   __u32 *addr, __u16 *port, char **start, char **end)
  2375. {
  2376.        unsigned ];
  2377. ;
  2378.  
  2379.        if (data_limit - data < plen) {
  2380.              /* check if there is partial match */
  2381. )
  2382. ;
  2383.              else
  2384.                     ;
  2385.        }
  2386.        //模式匹配,"PORT "或"227 "
  2387. ) {
  2388. ;
  2389.        }
  2390.        *start = data + plen;
  2391.  
  2392.        for (data = *start; *data != term; data++) {
  2393.              if (data == data_limit)
  2394. ;
  2395.        }
  2396.        *end = data;
  2397.        memset(p, , sizeof(p));
  2398.  
  2399.        //解析出6个数值
  2400.        for (data = *start; data != *end; data++) {
  2401. ') {
  2402.                     p[i] = p[i]* + *data - ';
  2403.              } ) {
  2404.                     i++;
  2405.              } else {
  2406.                     /* unexpected character */
  2407. ;
  2408.              }
  2409.        }
  2410.  
  2411. )
  2412. ;
  2413.        //前4个是地址
  2414.        *addr = (p[]<<) | (p[]<<) | (p[]<<) | p[];
  2415.        //后两个是端口
  2416.        *port = (p[]<<) | p[];
  2417. ;
  2418. }
  2419. 进入方向的数据是FTP客户端发出的, 和子连接相关的命令为PORT命令,建立一个主动模式的子连接
  2420. static int ip_vs_ftp_in(struct ip_vs_app *app, struct ip_vs_conn *cp, struct sk_buff **pskb, int *diff)
  2421. {
  2422.        struct iphdr *iph;
  2423.        struct tcphdr *th;
  2424.        char *data, *data_start, *data_limit;
  2425.        char *start, *end;
  2426.        __u32 to;
  2427.        __u16 port;
  2428.        struct ip_vs_conn *n_cp;
  2429.  
  2430.       *diff = ;
  2431.       //发子连接信息数据时主连接必然是TCP连接建立好状态,否则就出错
  2432.       if (cp->state != IP_VS_TCP_S_ESTABLISHED)
  2433. ;
  2434.       //让数据包可写
  2435.       if (!ip_vs_make_skb_writable(pskb, (*pskb)->len))
  2436. ;
  2437.       //协议头指针定位
  2438.       iph = (*pskb)->nh.iph;
  2439.       th = (]);
  2440.  
  2441.       /* Since there may be OPTIONS in the TCP packet and the HLEN is
  2442.          the length of the header in 32-bit multiples, it is accurate
  2443.          to calculate data address by th+HLEN*4 */
  2444.       //数据定位
  2445.       data = data_start = ();
  2446.       data_limit = (*pskb)->tail;
  2447.  
  2448.       //防止数据越界
  2449. ) {
  2450.             //PASV命令,表示要进入被动模式
  2451. ) == ) {
  2452.                   /* Passive mode on */
  2453.                   cp->app_data = &ip_vs_ftp_pasv;
  2454. ;
  2455.             }
  2456.             data++;
  2457.        }
  2458.        //#define CLIENT_STRING "PORT "
  2459.        // 查找FTP数据是否是PORT命令,提取出地址端口信息及其位置
  2460. , )
  2461. ;
  2462.        cp->app_data = NULL;
  2463.  
  2464.        //用找到的地址端口和服务器虚地址虚端口找连接
  2465.        n_cp = ip_vs_conn_in_get(iph->protocol, to, port, cp->vaddr, htons(ntohs(cp->vport)-));
  2466.        if (!n_cp) {//找不到连接,这是大部分的情况
  2467.               //新建连接作为子连接
  2468.               n_cp = ip_vs_conn_new(IPPROTO_TCP, to, port, cp->vaddr, htons(ntohs(cp->vport)-),
  2469.                                       cp->daddr, htons(ntohs(cp->dport)-), , cp->dest);
  2470.               if (!n_cp)
  2471. ;
  2472.  
  2473.               //子连接和主连接相连
  2474.               //不需要修改数据内容
  2475.               ip_vs_control_add(n_cp, cp);
  2476.        }
  2477.        //将子连接状态设置为监听状态
  2478.        ip_vs_tcp_conn_listen(n_cp);
  2479.        ip_vs_conn_put(n_cp);
  2480. ;
  2481. }
  2482. 初始化
  2483. #define IP_VS_APP_MAX_PORTS  8
  2484. , };
  2485. static int __init ip_vs_ftp_init(void)
  2486. {
  2487.        int i, ret;
  2488.        struct ip_vs_app *app = &ip_vs_ftp;
  2489.        //注册FTP应用模板
  2490.        ret = register_ip_vs_app(app); //实现list_add(&app->a_list, &ip_vs_app_list); ip_vs_app_list全局连表
  2491.        if (ret)
  2492.              return ret;
  2493.        //可从模块插入时，输入端口参数，指定在哪些端口上进行FTP应用绑定
  2494. ; i<IP_VS_APP_MAX_PORTS; i++) {
  2495.              if (!ports[i])
  2496.                    continue;
  2497.  || ports[i] > 0xffff) {
  2498.                    IP_VS_WARNING("ip_vs_ftp: Ignoring invalid configuration port[%d] = %d\n", i, ports[i]);
  2499.                    continue;
  2500.              }
  2501.              //新建应用实例
  2502.              ret = register_ip_vs_app_inc(app, app->protocol, ports[i]); //实现result = ip_vs_app_inc_new(app, proto, port);
  2503.              if (ret)
  2504.                    break;
  2505.  
  2506.              IP_VS_INFO("%s: loaded support on port[%d] = %d\n", app->name, i, ports[i]);
  2507.        }
  2508.        if (ret)
  2509.              unregister_ip_vs_app(app);
  2510.        return ret;
  2511. }
  2512. //新建一个应用实例,注意输入参数除了协议端口外,还需要提供一个应用模板的指针
  2513. //而且函数并不直接返回应用结构本身,而是在函数中新建的应用实例直接挂接到链表中
  2514. //只返回建立成功(0)或失败(<0)
  2515. static int ip_vs_app_inc_new(struct ip_vs_app *app, __u16 proto, __u16 port)
  2516. {
  2517.       struct ip_vs_protocol *pp;
  2518.       struct ip_vs_app *inc;
  2519.       int ret;
  2520.  
  2521.       //查找IPVS协议结构
  2522.       if (!(pp = ip_vs_proto_get(proto)))
  2523.             return -EPROTONOSUPPORT;
  2524.       //协议中不能只有应用登记函数而没有拆除函数
  2525.       if (!pp->unregister_app)
  2526.             return -EOPNOTSUPP;
  2527.  
  2528.       //分配应用结构内存
  2529.       inc = kmalloc(sizeof(struct ip_vs_app), GFP_KERNEL);
  2530.       if (!inc)
  2531.             return -ENOMEM;
  2532.       //将应用模板中的内容全部拷贝到新应用结构中
  2533.       memcpy(inc, app, sizeof(*inc));
  2534.       INIT_LIST_HEAD(&inc->p_list);
  2535.       INIT_LIST_HEAD(&inc->incs_list);
  2536.       inc->app = app;//应用实例中指向模板本身的指针
  2537.       inc->port = htons(port);//应用协议的端口
  2538.       atomic_set(&inc->usecnt, );//实例的使用计数
  2539.  
  2540.       if (app->timeouts) { //建立应用协议状态超时数组
  2541.             inc->timeout_table = ip_vs_create_timeout_table(app->timeouts, app->timeouts_size);
  2542.             if (!inc->timeout_table) {
  2543.                   ret = -ENOMEM;
  2544.                   goto out;
  2545.             }
  2546.       }
  2547.       //将应用实例向IP协议结构登记
  2548.       ret = pp->register_app(inc);
  2549.       if (ret)
  2550.             goto out;
  2551.  
  2552.       //将应用实例添加到应用模板的实例链表
  2553.       list_add(&inc->a_list, &app->incs_list);
  2554.       IP_VS_DBG(, "%s application %s:%u registered\n", pp->name, inc->name, inc->port);
  2555. ;
  2556. out:
  2557.       kfree(inc->timeout_table);
  2558.       kfree(inc);
  2559.       return ret;
  2560. }
  2561. [/处理多连接协议]
  2562. [控制接口实现]
  2563. IPVS控制包括定义IPVS提供的虚拟服务参数和实际的目的服务器等各种参数。
  2564. IPVS的控制信息是通过setsockopt系统调用传递到内核的，IPVS在用户层的管理工具是ipvsadm。
  2565. 用netfilter的struct nf_sockopt_ops结构来添加
  2566. static struct nf_sockopt_ops ip_vs_sockopts = {
  2567.         .pf             = PF_INET,
  2568.         .set_optmin     = IP_VS_BASE_CTL,
  2569.         .set_optmax     = IP_VS_SO_SET_MAX+,
  2570.         .set            = do_ip_vs_set_ctl,
  2571.         .get_optmin     = IP_VS_BASE_CTL,
  2572.         .get_optmax     = IP_VS_SO_GET_MAX+,
  2573.         .get            = do_ip_vs_get_ctl,
  2574. };
  2575. 写控制
  2576. static int do_ip_vs_set_ctl(struct sock *sk, int cmd, void __user *user, unsigned int len)
  2577. {
  2578.        int ret;
  2579.        unsigned char arg[MAX_ARG_LEN];
  2580.        struct ip_vs_service_user *usvc;
  2581.        struct ip_vs_service *svc;
  2582.        struct ip_vs_dest_user *udest;
  2583.  
  2584.        //当前进程有网络管理权限
  2585.        if (!capable(CAP_NET_ADMIN))
  2586.               return -EPERM;
  2587.  
  2588.        //检查从用户空间传过来的数据长度是否正确
  2589.        if (len != set_arglen[SET_CMDID(cmd)]) {
  2590.               IP_VS_ERR("set_ctl: len %u != %u\n", len, set_arglen[SET_CMDID(cmd)]);
  2591.               return -EINVAL;
  2592.        }
  2593.        //将数据从用户空间拷贝到内核空间
  2594. )
  2595.              return -EFAULT;
  2596.        ip_vs_use_count_inc();
  2597.        //可中断互斥锁
  2598.        if (mutex_lock_interruptible(&__ip_vs_mutex)) {
  2599.              ret = -ERESTARTSYS;
  2600.              goto out_dec;
  2601.        }
  2602.  
  2603.        if (cmd == IP_VS_SO_SET_FLUSH) {
  2604.              /* Flush the virtual service */
  2605.              ret = ip_vs_flush();//删除所有虚拟服务
  2606.              goto out_unlock;
  2607.        } else if (cmd == IP_VS_SO_SET_TIMEOUT) {
  2608.              /* Set timeout values for (tcp tcpfin udp) */
  2609.              ret = ip_vs_set_timeout((struct ip_vs_timeout_user *)arg);//设置超时时间
  2610.              goto out_unlock;
  2611.        } else if (cmd == IP_VS_SO_SET_STARTDAEMON) {
  2612.              struct ip_vs_daemon_user *dm = (struct ip_vs_daemon_user *)arg;
  2613.              ret = start_sync_thread(dm->state, dm->mcast_ifn, dm->syncid);//启动IPVS同步进程
  2614.              goto out_unlock;
  2615.        } else if (cmd == IP_VS_SO_SET_STOPDAEMON) {
  2616.              struct ip_vs_daemon_user *dm = (struct ip_vs_daemon_user *)arg;
  2617.              ret = stop_sync_thread(dm->state); //停止IPVS同步进程
  2618.              goto out_unlock;
  2619.        }
  2620.  
  2621.        usvc = (struct ip_vs_service_user *)arg;
  2622.        udest = ();
  2623.  
  2624.        if (cmd == IP_VS_SO_SET_ZERO) {
  2625.              /* if no service address is set, zero counters in all */
  2626.             if (!usvc->fwmark && !usvc->addr && !usvc->port) {
  2627.                   ret = ip_vs_zero_all();//所有计数器清零
  2628.                   goto out_unlock;
  2629.             }
  2630.        }
  2631.  
  2632.        //检查协议是否正确,必须是TCP或UDP
  2633.        if (usvc->protocol != IPPROTO_TCP && usvc->protocol != IPPROTO_UDP) {
  2634.               IP_VS_ERR("set_ctl: invalid protocol: %d %d.%d.%d.%d:%d %s\n", usvc->protocol, NIPQUAD(usvc->addr),
  2635.                           ntohs(usvc->port), usvc->sched_name);
  2636.               ret = -EFAULT;
  2637.               goto out_unlock;
  2638.        }
  2639.  
  2640.        /* Lookup the exact service by <protocol, addr, port> or fwmark */
  2641. )
  2642.              svc = __ip_vs_service_get(usvc->protocol, usvc->addr, usvc->port);
  2643.        else
  2644.              svc = __ip_vs_svc_fwm_get(usvc->fwmark);
  2645.  
  2646.        //不是添加命令的话,服务不能为空,或者协议不匹配
  2647.        if (cmd != IP_VS_SO_SET_ADD && (svc == NULL || svc->protocol != usvc->protocol)) {
  2648.              ret = -ESRCH;
  2649.              goto out_unlock;
  2650.        }
  2651.  
  2652.        switch (cmd) {
  2653.        case IP_VS_SO_SET_ADD:
  2654.              if (svc != NULL)
  2655.                    ret = -EEXIST;
  2656.              else
  2657.                    ret = ip_vs_add_service(usvc, &svc);//添加服务
  2658.              break;
  2659.        case IP_VS_SO_SET_EDIT:
  2660.              ret = ip_vs_edit_service(svc, usvc);//修改服务参数
  2661.              break;
  2662.        case IP_VS_SO_SET_DEL:
  2663.              ret = ip_vs_del_service(svc);//删除服务
  2664.             if (!ret)
  2665.                   goto out_unlock;
  2666.             break;
  2667.        case IP_VS_SO_SET_ZERO:
  2668.             ret = ip_vs_zero_service(svc);//服务数据清零
  2669.             break;
  2670.        case IP_VS_SO_SET_ADDDEST:
  2671.             ret = ip_vs_add_dest(svc, udest);//添加目的服务器
  2672.             break;
  2673.        case IP_VS_SO_SET_EDITDEST:
  2674.             ret = ip_vs_edit_dest(svc, udest);//修改目的服务器参数
  2675.             break;
  2676.        case IP_VS_SO_SET_DELDEST:
  2677.             ret = ip_vs_del_dest(svc, udest);//删除目的服务器
  2678.             break;
  2679.        default:
  2680.             ret = -EINVAL;
  2681.        }
  2682.  
  2683.       if (svc)//减少服务的引用计数
  2684.             ip_vs_service_put(svc);
  2685. out_unlock:
  2686.       mutex_unlock(&__ip_vs_mutex);
  2687. out_dec:
  2688.       /* decrease the module use count */
  2689.       ip_vs_use_count_dec();
  2690.       return ret;
  2691. }
  2692. 读控制
  2693. static int do_ip_vs_get_ctl(struct sock *sk, int cmd, void __user *user, int *len)
  2694. {
  2695.       unsigned ];
  2696. ;
  2697.  
  2698.       if (!capable(CAP_NET_ADMIN))
  2699.              return -EPERM;
  2700.  
  2701.       if (*len < get_arglen[GET_CMDID(cmd)]) {
  2702.              IP_VS_ERR("get_ctl: len %u < %u\n", *len, get_arglen[GET_CMDID(cmd)]);
  2703.              return -EINVAL;
  2704.       }
  2705.  
  2706. )
  2707.              return -EFAULT;
  2708.  
  2709.       if (mutex_lock_interruptible(&__ip_vs_mutex))
  2710.              return -ERESTARTSYS;
  2711. switch (cmd) {case IP_VS_SO_GET_VERSION: //读取IPVS版本信息
  2712.       {
  2713. ];
  2714.              sprintf(buf, "IP Virtual Server version %d.%d.%d (size=%d)", NVERSION(IP_VS_VERSION_CODE), IP_VS_CONN_TAB_SIZE);
  2715. ) != ) {
  2716.                    ret = -EFAULT;
  2717.                    goto out;
  2718.              }
  2719.              *len = strlen(buf)+;
  2720.       }
  2721.       break;
  2722.       case IP_VS_SO_GET_INFO://IPVS基本信息:版本号,连接HASH数,服务数
  2723.       {
  2724.              struct ip_vs_getinfo info;
  2725.              info.version = IP_VS_VERSION_CODE;
  2726.              info.size = IP_VS_CONN_TAB_SIZE;
  2727.              info.num_services = ip_vs_num_services;
  2728. )
  2729.                    ret = -EFAULT;
  2730.        }
  2731.        break;
  2732.        case IP_VS_SO_GET_SERVICES://获取IPVS服务表
  2733.        {
  2734.              struct ip_vs_get_services *get;
  2735.              int size;
  2736.  
  2737.              get = (struct ip_vs_get_services *)arg;
  2738.              size = sizeof(*get) + sizeof(struct ip_vs_service_entry) * get->num_services;
  2739.              if (*len != size) {
  2740.                    IP_VS_ERR("length: %u != %u\n", *len, size);
  2741.                    ret = -EINVAL;
  2742.                    goto out;
  2743.              }
  2744.              ret = __ip_vs_get_service_entries(get, user);
  2745.        }
  2746.        break;
  2747.        case IP_VS_SO_GET_SERVICE://获取单个IPVS服务
  2748.        {
  2749.              struct ip_vs_service_entry *entry;
  2750.              struct ip_vs_service *svc;
  2751.  
  2752.              entry = (struct ip_vs_service_entry *)arg;
  2753.              if (entry->fwmark)
  2754.                    svc = __ip_vs_svc_fwm_get(entry->fwmark);
  2755.              else
  2756.                    svc = __ip_vs_service_get(entry->protocol, entry->addr, entry->port);
  2757.              if (svc) {
  2758.                    ip_vs_copy_service(entry, svc);
  2759. )
  2760.                          ret = -EFAULT;
  2761.                    ip_vs_service_put(svc);
  2762.              } else
  2763.                    ret = -ESRCH;
  2764.        }
  2765.        break;
  2766.        case IP_VS_SO_GET_DESTS://获取目的服务器表
  2767.        {
  2768.               struct ip_vs_get_dests *get;
  2769.               int size;
  2770.  
  2771.               get = (struct ip_vs_get_dests *)arg;
  2772.               size = sizeof(*get) + sizeof(struct ip_vs_dest_entry) * get->num_dests;
  2773.               if (*len != size) {
  2774.                     IP_VS_ERR("length: %u != %u\n", *len, size);
  2775.                     ret = -EINVAL;
  2776.                     goto out;
  2777.               }
  2778.               ret = __ip_vs_get_dest_entries(get, user);
  2779.        }
  2780.        break;
  2781.        case IP_VS_SO_GET_TIMEOUT://获取tcp状态超时时间
  2782.        {
  2783.               struct ip_vs_timeout_user t;
  2784.               __ip_vs_get_timeouts(&t);
  2785. )
  2786.                     ret = -EFAULT;
  2787.  
  2788.        }
  2789.        break;
  2790.        case IP_VS_SO_GET_DAEMON://获取同步进程信息:状态,同步通信网卡,同步ID
  2791.        {
  2792. ];
  2793.               memset(&d, , sizeof(d));
  2794.               if (ip_vs_sync_state & IP_VS_STATE_MASTER) {
  2795.                      d[].state = IP_VS_STATE_MASTER;
  2796.                      strlcpy(d[].mcast_ifn, ip_vs_master_mcast_ifn, ].mcast_ifn));
  2797.                      d[].syncid = ip_vs_master_syncid;
  2798.               }
  2799.               if (ip_vs_sync_state & IP_VS_STATE_BACKUP) {
  2800.                      d[].state = IP_VS_STATE_BACKUP;
  2801.                      strlcpy(d[].mcast_ifn, ip_vs_backup_mcast_ifn, ].mcast_ifn));
  2802.                      d[].syncid = ip_vs_backup_syncid;
  2803.               }
  2804. )
  2805.                     ret = -EFAULT;
  2806.        }
  2807.        break;
  2808.        default:
  2809.              ret = -EINVAL;
  2810.        }
  2811. out:
  2812.        mutex_unlock(&__ip_vs_mutex);
  2813.        return ret;
  2814. }
  2815. 添加服务
  2816. static int ip_vs_add_service(struct ip_vs_service_user *u, struct ip_vs_service **svc_p)
  2817. {
  2818. ;
  2819.       struct ip_vs_scheduler *sched = NULL;
  2820.       struct ip_vs_service *svc = NULL;
  2821.  
  2822.       /* increase the module use count */
  2823.       ip_vs_use_count_inc();
  2824.  
  2825.       //根据名称查找调度算法结构
  2826.       sched = ip_vs_scheduler_get(u->sched_name);
  2827.       if (sched == NULL) {
  2828.             IP_VS_INFO("Scheduler module ip_vs_%s not found\n", u->sched_name);
  2829.             ret = -ENOENT;
  2830.             goto out_mod_dec;
  2831.       }
  2832.  
  2833.       svc = kzalloc(sizeof(struct ip_vs_service), GFP_ATOMIC);
  2834.       if (svc == NULL) {
  2835.             IP_VS_DBG(, "ip_vs_add_service: kmalloc failed.\n");
  2836.             ret = -ENOMEM;
  2837.             goto out_err;
  2838.       }
  2839.       //初始值: 使用数1, 引用数0
  2840.       atomic_set(&svc->usecnt, );
  2841.       atomic_set(&svc->refcnt, );
  2842.       //根据用户空间传递过来的参数初始化服务参数
  2843.       svc->protocol = u->protocol;
  2844.       svc->addr = u->addr;
  2845.       svc->port = u->port;
  2846.       svc->fwmark = u->fwmark;
  2847.       svc->flags = u->flags;
  2848.       svc->timeout = u->timeout * HZ;
  2849.       svc->netmask = u->netmask;
  2850.       //初始化服务结构中的内核相关参数
  2851.       //目的服务器链表初始化
  2852.       INIT_LIST_HEAD(&svc->destinations);
  2853.       rwlock_init(&svc->sched_lock);
  2854.       spin_lock_init(&svc->stats.lock);
  2855.  
  2856.       //将服务和调度算法绑定
  2857.       ret = ip_vs_bind_scheduler(svc, sched);
  2858.       if (ret)
  2859.             goto out_err;
  2860.       sched = NULL;
  2861.  
  2862.       //端口是FTP或0时增加相关计数器,这里应该象netfilter那样建立一个服务helper,
  2863.       //根据端口自动查找对应的helper,统一处理,就不用在程序中明确指定特殊服务端口号了
  2864.       if (svc->port == FTPPORT)
  2865.             atomic_inc(&ip_vs_ftpsvc_counter);
  2866. )
  2867.             atomic_inc(&ip_vs_nullsvc_counter);
  2868.       //建立服务状态预估器,用于根据服务的连接数,包数等调整均衡策略，看下面IPVS预估器
  2869.       ip_vs_new_estimator(&svc->stats);
  2870.       ip_vs_num_services++;//IPVS服务数增加
  2871.  
  2872.       //将服务挂接到服务HASH表中
  2873.       write_lock_bh(&__ip_vs_svc_lock);
  2874.       ip_vs_svc_hash(svc);
  2875.       write_unlock_bh(&__ip_vs_svc_lock);
  2876.  
  2877.       *svc_p = svc;//返回的新服务指针
  2878. ;
  2879.       ......
  2880. }
  2881. 目的服务器是实际提供对外服务的服务器，由结构struct ip_vs_dest描述，该结构的具体对象可以很多，每个结构描述一个具体的服务器，
  2882. 目的服务器参数是通过ipvsadm命令添加的，命令为:
  2883. ipvsadm -a -t/u v_srv_ip:vport -r dest_ip:dest_port -w weight
  2884.  
  2885. 添加服务器
  2886. static int ip_vs_add_dest(struct ip_vs_service *svc, struct ip_vs_dest_user *udest)
  2887. {
  2888.       struct ip_vs_dest *dest;
  2889.       __u32 daddr = udest->addr;
  2890.       __u16 dport = udest->port;
  2891.       int ret;
  2892.  
  2893.       //每个服务器权重值不能小于0
  2894. ) {
  2895.             IP_VS_ERR("ip_vs_add_dest(): server weight less than zero\n");
  2896.             return -ERANGE;
  2897.       }
  2898.  
  2899.       //阈值上限要不能小于下限
  2900.       if (udest->l_threshold > udest->u_threshold) {
  2901.             IP_VS_ERR("ip_vs_add_dest(): lower threshold is higher than upper threshold\n");
  2902.             return -ERANGE;
  2903.       }
  2904.  
  2905.       //根据目的地址和目的端口查找服务器是否已经存在
  2906.       dest = ip_vs_lookup_dest(svc, daddr, dport);
  2907.       if (dest != NULL) {
  2908.              IP_VS_DBG(, "ip_vs_add_dest(): dest already exists\n");
  2909.              return -EEXIST;
  2910.       }
  2911.  
  2912.       //在准备释放的垃圾内存中检查是否有目的服务器存在
  2913.       dest = ip_vs_trash_get_dest(svc, daddr, dport);
  2914.       if (dest != NULL) {
  2915.             //找到目的服务器,恢复目的服务器的使用
  2916.             //更新目的服务器
  2917.             __ip_vs_update_dest(svc, dest, udest);
  2918.             //从垃圾链表中拆除
  2919.             list_del(&dest->n_list);
  2920.             //新建目的服务器的预估器
  2921.             ip_vs_new_estimator(&dest->stats);
  2922.  
  2923.             write_lock_bh(&__ip_vs_svc_lock);
  2924.             IP_VS_WAIT_WHILE(atomic_read(&svc->usecnt) > );
  2925.             //添加到服务的目的服务器链表中
  2926.             list_add(&dest->n_list, &svc->destinations);
  2927.             svc->num_dests++;
  2928.  
  2929.             /* call the update_service function of its scheduler */
  2930.             svc->scheduler->update_service(svc);
  2931.  
  2932.             write_unlock_bh(&__ip_vs_svc_lock);
  2933. ;
  2934.       }
  2935.  
  2936.       //目的服务器不存在,重新分配内存建立一个
  2937.       ret = ip_vs_new_dest(svc, udest, &dest);
  2938.       if (ret) {
  2939.             return ret;
  2940.       }
  2941.       atomic_inc(&dest->refcnt);//增加目的服务器引用计数
  2942.  
  2943.       write_lock_bh(&__ip_vs_svc_lock);
  2944.       IP_VS_WAIT_WHILE(atomic_read(&svc->usecnt) > );
  2945.       //将目的服务器添加到服务的服务器链表
  2946.       list_add(&dest->n_list, &svc->destinations);
  2947.       svc->num_dests++;
  2948.  
  2949.       //更新调度算法的调度处理
  2950.       svc->scheduler->update_service(svc);
  2951.       write_unlock_bh(&__ip_vs_svc_lock);
  2952. ;
  2953. }
  2954. [/控制接口实现]
  2955. [IPVS的同步]
  2956. IPVS支持对连接的同步，两台IPVS设备可分别以MASTER或BACKUP运行，MASTER进程可将连接信息备份到BACKUP设备上,这样主设备死机时从设备可以无缝切换。
  2957. 可以在IPVS设备上同时启动MASTER和BACKUP进程，使设备之间互为备份，实现IPVS设备的均衡。
  2958. IPVS同步实现在net/ipv4/ipvs/ip_vs_sync.c中.
  2959. 同步信息块的格式如下,开始是4字节的信息头,后面是多个IPVS连接同步信息,每个块大小不固定,连接同步信息个数从0到多个:
  2960.  
  2961.       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  2962.       | Count Conns    |    SyncID     |            Size                |
  2963.       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  2964.       |                                                                   |
  2965.       |                    IPVS Sync Connection ()                     |
  2966.       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  2967.       |                            .                                      |
  2968.       |                            .                                      |
  2969.       |                            .                                      |
  2970.       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  2971.       |                                                                   |
  2972.       |                    IPVS Sync Connection (n)                     |
  2973.       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  2974.  
  2975. 数据结构
  2976. #define SYNC_MESG_HEADER_LEN    4
  2977. 信息头结构
  2978. struct ip_vs_sync_mesg {
  2979.         __u8                    nr_conns; // 连接数
  2980.         __u8                    syncid; // 同步ID
  2981.         __u16                   size; // 数据总长
  2982.         /* ip_vs_sync_conn entries start here */
  2983. };
  2984. IPVS连接同步信息结构
  2985. struct ip_vs_sync_conn {
  2986.         __u8                    reserved;
  2987.         // 连接基本信息
  2988.         /* Protocol, addresses and port numbers */
  2989.         __u8                    protocol;       /* Which protocol (TCP/UDP) */
  2990.         __u16                   cport;
  2991.         __u16                   vport;
  2992.         __u16                   dport;
  2993.         __u32                   caddr;          /* client address */
  2994.         __u32                   vaddr;          /* virtual address */
  2995.         __u32                   daddr;          /* destination address */
  2996.         // 连接的状态和标志
  2997.         /* Flags and state transition */
  2998.         __u16                   flags;          /* status flags */
  2999.         __u16                   state;          /* state info */
  3000.         // 后续可能有连接选项参数,就是TCP的序列号和确认号信息
  3001.         /* The sequence options start here */
  3002. };
  3003. IPVS连接同步选项结构,,就是进入和发出发现TCP的序列号信息
  3004. struct ip_vs_sync_conn_options {
  3005.         struct ip_vs_seq        in_seq;         /* incoming seq. struct */
  3006.         struct ip_vs_seq        out_seq;        /* outgoing seq. struct */
  3007. };
  3008. 连接数据控制块结构
  3009. struct ip_vs_sync_buff {
  3010.         struct list_head        list; // 形成队列
  3011.         unsigned long           firstuse;
  3012.         //实际的同步信息
  3013.         /* pointers for the message data */
  3014.         struct ip_vs_sync_mesg  *mesg;
  3015.         unsigned char           *head;
  3016.         unsigned char           *end;
  3017. };
  3018. IPVS同步进程是一个内核进程，是由IPVSADM通过命令启动的.
  3019. int start_sync_thread(int state, char *mcast_ifn, __u8 syncid)
  3020. {
  3021.       DECLARE_COMPLETION_ONSTACK(startup);
  3022.       pid_t pid;
  3023.       //检查进程是否已经存在
  3024.       if ((state == IP_VS_STATE_MASTER && sync_master_pid) || (state == IP_VS_STATE_BACKUP && sync_backup_pid))
  3025.             return -EEXIST;
  3026.       ip_vs_sync_state |= state;
  3027.       if (state == IP_VS_STATE_MASTER) {//MASTER进程
  3028.             //通信的网卡
  3029.             strlcpy(ip_vs_master_mcast_ifn, mcast_ifn, sizeof(ip_vs_master_mcast_ifn));
  3030.             ip_vs_master_syncid = syncid; //同步ID
  3031.       } else {//SLAVE进程
  3032.             strlcpy(ip_vs_backup_mcast_ifn, mcast_ifn, sizeof(ip_vs_backup_mcast_ifn));
  3033.             ip_vs_backup_syncid = syncid;
  3034.       }
  3035. repeat:
  3036. )) < ) { //启动内核进程
  3037.             IP_VS_ERR("could not create fork_sync_thread due to %d... retrying.\n", pid);
  3038.             ssleep();
  3039.             goto repeat;
  3040.       }
  3041.       wait_for_completion(&startup);
  3042. ;
  3043. }
  3044. fork_sync_thread()函数也继续fork出一个进程,形成守护进程
  3045. static int fork_sync_thread(void *startup)
  3046. {
  3047.         pid_t pid;
  3048.  
  3049.         /* fork the sync thread here, then the parent process of the
  3050.            sync thread is the init process after this thread exits. */
  3051. repeat:
  3052.         )) < ) {
  3053.                 IP_VS_ERR("could not create sync_thread due to %d... "
  3054.                           "retrying.\n", pid);
  3055.                 ssleep();
  3056.                 goto repeat;
  3057.         }
  3058.         ;
  3059. }
  3060. static int sync_thread(void *startup)
  3061. {
  3062.       DECLARE_WAITQUEUE(wait, current);
  3063.       mm_segment_t oldmm;
  3064.       int state;
  3065.       const char *name;
  3066.  
  3067.       /* increase the module use count */
  3068.       ip_vs_use_count_inc();
  3069.       //设置进程状态的名称
  3070.       if (ip_vs_sync_state & IP_VS_STATE_MASTER && !sync_master_pid) {
  3071.             state = IP_VS_STATE_MASTER;
  3072.             name = "ipvs_syncmaster";
  3073.       } else if (ip_vs_sync_state & IP_VS_STATE_BACKUP && !sync_backup_pid) {
  3074.             state = IP_VS_STATE_BACKUP;
  3075.             name = "ipvs_syncbackup";
  3076.       } else {
  3077.             IP_VS_BUG();
  3078.             ip_vs_use_count_dec();
  3079.             return -EINVAL;
  3080.       }
  3081.  
  3082.       daemonize(name);//daemon化进程
  3083.  
  3084.       oldmm = get_fs();
  3085.       set_fs(KERNEL_DS);
  3086.  
  3087.       /* Block all signals */
  3088.       spin_lock_irq(&current->sighand->siglock);
  3089.       siginitsetinv(&current->blocked, ); //本进程不接收所有信号
  3090.       recalc_sigpending();
  3091.       spin_unlock_irq(&current->sighand->siglock);
  3092.  
  3093.       /* set the maximum length of sync message */
  3094.       set_sync_mesg_maxlen(state); //设置最大同步信息长度
  3095.  
  3096.       //#define IP_VS_SYNC_GROUP 0xe0000051    /* multicast addr - 224.0.0.81 */
  3097.       //#define IP_VS_SYNC_PORT  8848          /* multicast port */
  3098.       //设置UDP多播sock的参数
  3099.       mcast_addr.sin_family = AF_INET;
  3100.       mcast_addr.sin_port = htons(IP_VS_SYNC_PORT);
  3101.       mcast_addr.sin_addr.s_addr = htonl(IP_VS_SYNC_GROUP);
  3102.  
  3103.       //增加等待队列,由于接收发送数据必须在top half中,在bottom half中
  3104.       //只是发个WQ信号告诉top half可以进行接收或发送数据了
  3105.       add_wait_queue(&sync_wait, &wait);
  3106.  
  3107.       set_sync_pid(state, current->pid); //保存当前进程的pid
  3108.       complete((struct completion *)startup);
  3109.  
  3110.      //分别进行MASTER或SLAVE循环
  3111.      if (state == IP_VS_STATE_MASTER)
  3112.            sync_master_loop();
  3113.      else if (state == IP_VS_STATE_BACKUP)
  3114.            sync_backup_loop();
  3115.      else
  3116.            IP_VS_BUG();
  3117.  
  3118.      //循环退出,删除等待队列
  3119.      remove_wait_queue(&sync_wait, &wait);
  3120.  
  3121.      /* thread exits */
  3122.      set_sync_pid(state, ); //清零
  3123.      IP_VS_INFO("sync thread stopped!\n");
  3124.  
  3125.      set_fs(oldmm);
  3126.      /* decrease the module use count */
  3127.      ip_vs_use_count_dec();
  3128.      set_stop_sync(state, );
  3129.      wake_up(&stop_sync_wait);
  3130. ;
  3131. }
  3132. MASTER循环
  3133. static void sync_master_loop(void)
  3134. {
  3135.       struct socket *sock;
  3136.       struct ip_vs_sync_buff *sb;
  3137.  
  3138.       /* create the sending multicast socket */
  3139.       sock = make_send_sock();//建立多播SOCK,同步信息由此SOCK发出
  3140.       if (!sock)
  3141.             return;
  3142.       for (;;) {//进入死循环
  3143.            //从队列中取发送数据块
  3144.            while ((sb=sb_dequeue())) {
  3145.                  ip_vs_send_sync_msg(sock, sb->mesg);//发出同步数据块
  3146.                  ip_vs_sync_buff_release(sb);//释放数据块缓冲
  3147.            }
  3148.            /* check if entries stay in curr_sb for 2 seconds */
  3149.           //如果2秒内数据块没准备好,直接将未完成的数据块发出去
  3150.           //最差情况下数据块里没有IPVS连接信息,只有一个数据头,
  3151.           //相当于同步信号,表明MASTER还没死
  3152. *HZ))) {
  3153.                 ip_vs_send_sync_msg(sock, sb->mesg);
  3154.                 ip_vs_sync_buff_release(sb);
  3155.           }
  3156.           //发现停止MASTER进程标志,中断循环
  3157.           if (stop_master_sync)
  3158.                 break;
  3159.           //休眠1秒
  3160.           ssleep();
  3161.       }
  3162.       //循环退出,将当前发送队列中的数据块都释放
  3163.       while ((sb=sb_dequeue())) {
  3164.             ip_vs_sync_buff_release(sb);
  3165.       }
  3166.  
  3167.       //清除当前块,当前块是构造中还没放到发送队列中的数据块
  3168. ))) {
  3169.             ip_vs_sync_buff_release(sb);
  3170.       }
  3171.  
  3172.       /* release the sending multicast socket */
  3173.       sock_release(sock);
  3174. }
  3175. BACKUP循环
  3176. static void sync_backup_loop(void)
  3177. {
  3178.       struct socket *sock;
  3179.       char *buf;
  3180.       int len;
  3181.       //分配数据接收空间
  3182.       if (!(buf = kmalloc(sync_recv_mesg_maxlen, GFP_ATOMIC))) {
  3183.             IP_VS_ERR("sync_backup_loop: kmalloc error\n");
  3184.             return;
  3185.       }
  3186.       //创建UDP接收SOCK，并把这个SOCK地址加入到多播组中
  3187.       sock = make_receive_sock();
  3188.       if (!sock)
  3189.             goto out;
  3190.       for (;;) {
  3191.             //接收队列非空
  3192.             while (!skb_queue_empty(&(sock->sk->sk_receive_queue))) {
  3193.                   //接收数据函数,比较简单,直接调用内核的kernel_recvmsg函数
  3194. ) {
  3195.                         IP_VS_ERR("receiving message error\n");
  3196.                         break;
  3197.                   }
  3198.                   /* disable bottom half, because it accessed the data shared by softirq while getting/creating conns */
  3199.                   local_bh_disable();//处理数据时不能再进入bottom half
  3200.                   ip_vs_process_message(buf, len);//处理接收数据
  3201.                   local_bh_enable();
  3202.             }
  3203.             //检查是否设置进程停止标志
  3204.             if (stop_backup_sync)
  3205.                   break;
  3206.             ssleep();//睡眠1秒
  3207.       }
  3208.       sock_release(sock);
  3209. out:
  3210.       kfree(buf);
  3211. }
  3212. 处理接收数据函数
  3213. static void ip_vs_process_message(const char *buffer, const size_t buflen)
  3214. {
  3215.       struct ip_vs_sync_mesg *m = (struct ip_vs_sync_mesg *)buffer;
  3216.       struct ip_vs_sync_conn *s;
  3217.       struct ip_vs_sync_conn_options *opt;
  3218.       struct ip_vs_conn *cp;
  3219.       char *p;
  3220.       int i;
  3221.  
  3222.       m->size = ntohs(m->size);
  3223.       //检查接收的数据长度是否正确
  3224.       if (buflen != m->size) {
  3225.             IP_VS_ERR("bogus message\n");
  3226.             return;
  3227.       }
  3228.       //检查同步ID是否匹配
  3229.  && m->syncid != ip_vs_backup_syncid) {
  3230.             IP_VS_DBG(, "Ignoring incoming msg with syncid = %d\n", m->syncid);
  3231.             return;
  3232.       }
  3233.  
  3234.       //同步信息块头后面是真正的IPVS连接同步信息
  3235.       //p现在是第一个同步连接结构指针
  3236.       p = (char *)buffer + sizeof(struct ip_vs_sync_mesg);
  3237.  
  3238. ; i < m->nr_conns; i++) {//循环读取缓冲区中的同步连接信息
  3239.             unsigned flags;
  3240.             s = (struct ip_vs_sync_conn *)p;
  3241.             flags = ntohs(s->flags);
  3242.  
  3243.             //根据同步连接信息查找连接
  3244.             if (!(flags & IP_VS_CONN_F_TEMPLATE))
  3245.                   cp = ip_vs_conn_in_get(s->protocol, s->caddr, s->cport, s->vaddr, s->vport);
  3246.             else
  3247.                   cp = ip_vs_ct_in_get(s->protocol, s->caddr, s->cport, s->vaddr, s->vport);
  3248.             if (!cp) {
  3249.                   //找不到连接,说明是MASTER新建的连接同步过来了
  3250.                   //新建连接,连接的dest参数为NULL,表明是同步产生的连接,而不是BACKUP自己生成的连接
  3251.                   cp = ip_vs_conn_new(s->protocol, s->caddr, s->cport, s->vaddr, s->vport, s->daddr, s->dport, flags, NULL);
  3252.                   if (!cp) {
  3253.                         IP_VS_ERR("ip_vs_conn_new failed\n");
  3254.                         return;
  3255.                   }
  3256.                   cp->state = ntohs(s->state);//设置连接状态
  3257.              } else if (!cp->dest) {
  3258.                   //找到了连接但没有dest指针,说明该连接是同步产生的连接,而不是BACKUP主动产生的连接
  3259.                   cp->state = ntohs(s->state);
  3260.                   cp->flags = flags | IP_VS_CONN_F_HASHED;
  3261.              } /* Note that we don't touch its state and flags if it is a normal entry. */
  3262.              if (flags & IP_VS_CONN_F_SEQ_MASK) {
  3263.                   //拷贝连接选项
  3264. ];
  3265.                   memcpy(&cp->in_seq, opt, sizeof(*opt));
  3266.                   p += FULL_CONN_SIZE;
  3267.              } else
  3268.                   p += SIMPLE_CONN_SIZE;
  3269.              //设置连接计数,是个固定值
  3270. ]);
  3271.              cp->timeout = IP_VS_SYNC_CONN_TIMEOUT;
  3272.              ip_vs_conn_put(cp);
  3273.  
  3274.              if (p > buffer + buflen) {//检查当前缓冲区指针是否越界了
  3275.                   IP_VS_ERR("bogus message\n");
  3276.                   return;
  3277.              }
  3278.       }
  3279. }
  3280. 还记得hook函数ip_vs_in()吗？连接同步函数ip_vs_sync_conn()是由ip_vs_in()函数调用的.
  3281. void ip_vs_sync_conn(struct ip_vs_conn *cp)
  3282. {
  3283.       struct ip_vs_sync_mesg *m;
  3284.       struct ip_vs_sync_conn *s;
  3285.       int len;
  3286.  
  3287.       spin_lock(&curr_sb_lock);
  3288.       if (!curr_sb) {
  3289.             //当前连接数据块为空,分配新块
  3290.             if (!(curr_sb=ip_vs_sync_buff_create())) {
  3291.                   spin_unlock(&curr_sb_lock);
  3292.                   IP_VS_ERR("ip_vs_sync_buff_create failed.\n");
  3293.                   return;
  3294.             }
  3295.       }
  3296.       //检查是否包括选项长度
  3297.       len = (cp->flags & IP_VS_CONN_F_SEQ_MASK) ? FULL_CONN_SIZE : SIMPLE_CONN_SIZE;
  3298.       m = curr_sb->mesg;
  3299.       //空闲缓冲区头,作为一个连接同步单元头
  3300.       s = (struct ip_vs_sync_conn *)curr_sb->head;
  3301.  
  3302.       /* copy members */
  3303.       s->protocol = cp->protocol;
  3304.       s->cport = cp->cport;
  3305.       s->vport = cp->vport;
  3306.       s->dport = cp->dport;
  3307.       s->caddr = cp->caddr;
  3308.       s->vaddr = cp->vaddr;
  3309.       s->daddr = cp->daddr;
  3310.       s->flags = htons(cp->flags & ~IP_VS_CONN_F_HASHED);
  3311.       s->state = htons(cp->state);
  3312.  
  3313.       if (cp->flags & IP_VS_CONN_F_SEQ_MASK) {//增加选项信息,即TCP序列号
  3314. ];
  3315.             memcpy(opt, &cp->in_seq, sizeof(*opt));
  3316.       }
  3317.  
  3318.       m->nr_conns++;
  3319.       m->size += len;//有效数据长度增加
  3320.       curr_sb->head += len;//空闲指针后移
  3321.  
  3322.       //检查剩下的空间是否还能容纳一个同步连接结构
  3323.       if (curr_sb->head + FULL_CONN_SIZE > curr_sb->end) {
  3324.             sb_queue_tail(curr_sb);//空间不够的话将当前同步数据块添加到发送链表中
  3325.             curr_sb = NULL;
  3326.       }
  3327.       spin_unlock(&curr_sb_lock);
  3328.  
  3329.       //如果有主连接,递归调用本函数同步主连接信息
  3330.       if (cp->control)
  3331.              ip_vs_sync_conn(cp->control);
  3332. }
  3333. [/IPVS的同步]
  3334. [IPVS预估器]
  3335. IPVS预估器估算在一个短暂时间间隔内的连接率,可在用户空间开一个daemon定时读取预估器的值以实现较长时间的预估。
  3336. 预估算法为：
  3337. 取最后8秒钟内，每两秒取一个采样点进行平滑处理：
  3338.     avgrate = avgrate*(-W) + rate*W
  3339.     其中 W = ^(-) = 0.25，速率单位是KBytes/s
  3340. 预估代码在net/ipv4/ipvs/ip_vs_est.c中实现.
  3341.  
  3342. struct ip_vs_estimator //预估器结构
  3343. {
  3344.         struct ip_vs_estimator  *next; //链表的下一项
  3345.         struct ip_vs_stats      *stats; //IPVS统计
  3346.  
  3347.         u32                     last_conns; // 上次的连接数
  3348.         u32                     last_inpkts; // 上次的进入包数
  3349.         u32                     last_outpkts; // 上次发出包数
  3350.         u64                     last_inbytes; // 上次进入字节数
  3351.         u64                     last_outbytes; // 上次发出字节数
  3352.  
  3353.         u32                     cps; // 连接率
  3354.         u32                     inpps; // 进入的包数率
  3355.         u32                     outpps; // 发出的包速率
  3356.         u32                     inbps; // 进入的速率
  3357.         u32                     outbps; // 发出的速率
  3358. };
  3359. int ip_vs_new_estimator(struct ip_vs_stats *stats)
  3360. {
  3361.       struct ip_vs_estimator *est;
  3362.  
  3363.       est = kzalloc(sizeof(*est), GFP_KERNEL); //分配空间
  3364.       if (est == NULL)
  3365.             return -ENOMEM;
  3366.  
  3367.       est->stats = stats; //统计结构,包括IPVS服务,目的服务器等都有这个统计结构,预估器就是根据此统计值计算
  3368.       est->last_conns = stats->conns; //将当前统计结构中的值作为预估器中的参数初始值
  3369.       est->cps = stats->cps<<; //连接率值扩大2^10
  3370.  
  3371.       est->last_inpkts = stats->inpkts;
  3372.       est->inpps = stats->inpps<<; //进入包速率值扩大2^10
  3373.  
  3374.       est->last_outpkts = stats->outpkts;
  3375.       est->outpps = stats->outpps<<; //发出包速率值扩大2^10
  3376.  
  3377.       est->last_inbytes = stats->inbytes;
  3378.       est->inbps = stats->inbps<<; //进入速率值扩大2^5
  3379.  
  3380.       est->last_outbytes = stats->outbytes;
  3381.       est->outbps = stats->outbps<<; //发出速率值扩大2^5
  3382.  
  3383.       write_lock_bh(&est_lock);
  3384.       est->next = est_list; //将结构加入链表
  3385.       if (est->next == NULL) { //初始化定时器,整个链表只有一个定时器
  3386.             init_timer(&est_timer);
  3387.             est_timer.expires = jiffies + *HZ; //超时两秒
  3388.             est_timer.function = estimation_timer;
  3389.             add_timer(&est_timer);
  3390.       }
  3391.       est_list = est;
  3392.       write_unlock_bh(&est_lock);
  3393. ;
  3394. }
  3395. 定时函数,预估计算
  3396. static void estimation_timer(unsigned long arg)
  3397. {
  3398.       struct ip_vs_estimator *e;
  3399.       struct ip_vs_stats *s;
  3400.       u32 n_conns;
  3401.       u32 n_inpkts, n_outpkts;
  3402.       u64 n_inbytes, n_outbytes;
  3403.       u32 rate;
  3404.  
  3405.       read_lock(&est_lock);
  3406.       //循环预估链表对所有预估器数据进行更新
  3407.       for (e = est_list; e; e = e->next) {
  3408.             s = e->stats;
  3409.  
  3410.             spin_lock(&s->lock);
  3411.             //当前统计结构中的新数值
  3412.             n_conns = s->conns;
  3413.             n_inpkts = s->inpkts;
  3414.             n_outpkts = s->outpkts;
  3415.             n_inbytes = s->inbytes;
  3416.             n_outbytes = s->outbytes;
  3417.  
  3418.             /* scaled by 2^10, but divided 2 seconds */
  3419.             //连接率计算
  3420.             //1秒内的连接数之差,扩大2^10
  3421.             rate = (n_conns - e->last_conns)<<;
  3422.             e->last_conns = n_conns;//保存连接数
  3423.             e->cps += ((;//预估器连接率变化
  3424.             s->cps = (e->cps+;//统计结构的连接率变化
  3425.  
  3426.             //进入包率计算,方法和上面相同
  3427.             rate = (n_inpkts - e->last_inpkts)<<;
  3428.             e->last_inpkts = n_inpkts;
  3429.             e->inpps += ((;
  3430.             s->inpps = (e->inpps+;
  3431.  
  3432.             //发出包率计算,方法和上面相同
  3433.             rate = (n_outpkts - e->last_outpkts)<<;
  3434.             e->last_outpkts = n_outpkts;
  3435.             e->outpps += ((;
  3436.             s->outpps = (e->outpps+;
  3437.  
  3438.             //进入字节流量率计算,方法和上面相同
  3439.             rate = (n_inbytes - e->last_inbytes)<<;
  3440.             e->last_inbytes = n_inbytes;
  3441.             e->inbps += ((;
  3442.             s->inbps = (e->inbps+;
  3443.  
  3444.             //发出字节流量率计算,方法和上面相同
  3445.             rate = (n_outbytes - e->last_outbytes)<<;
  3446.             e->last_outbytes = n_outbytes;
  3447.             e->outbps += ((;
  3448.             s->outbps = (e->outbps+;
  3449.             spin_unlock(&s->lock);
  3450.       }
  3451.       read_unlock(&est_lock);
  3452.       mod_timer(&est_timer, jiffies + *HZ);
  3453. }
  3454. [/IPVS预估器]
  3455.  
  3456. IPVS有个定时函数周期性根据当前系统配置和性能状况调整IPVS的防御级别.
  3457. #define DEFENSE_TIMER_PERIOD 1*HZ
  3458. static void defense_work_handler(void *data);
  3459. static DECLARE_WORK(defense_work, defense_work_handler, NULL);
  3460. static void defense_work_handler(void *data)
  3461. {
  3462.         update_defense_level();//更新防御级别
  3463.         if (atomic_read(&ip_vs_dropentry))
  3464.                 ip_vs_random_dropentry();
  3465.  
  3466.         schedule_delayed_work(&defense_work, DEFENSE_TIMER_PERIOD);
  3467. }
  3468. 更新IPVS的防御级别,需要用到/proc下定义的一些控制参数
  3469. static void update_defense_level(void)
  3470. {
  3471.       struct sysinfo i;
  3472. ;
  3473.       int availmem;
  3474.       int nomem;
  3475. ;
  3476.  
  3477.       si_meminfo(&i);//计算可用的内存量
  3478.       availmem = i.freeram + i.bufferram;
  3479.  
  3480.       nomem = (availmem < sysctl_ip_vs_amemthresh);
  3481.       local_bh_disable();
  3482.       spin_lock(&__ip_vs_dropentry_lock);
  3483.       switch (sysctl_ip_vs_drop_entry) {//删除连接策略
  3484. :
  3485.            atomic_set(&ip_vs_dropentry, );//不丢包
  3486.            break;
  3487. :
  3488.            if (nomem) {
  3489.                  atomic_set(&ip_vs_dropentry, );//内存不足时允许丢
  3490. ;
  3491.            } else {
  3492.                  atomic_set(&ip_vs_dropentry, );//内存足时不用丢
  3493.            }
  3494.            break;
  3495. :
  3496.            if (nomem) {
  3497.                  atomic_set(&ip_vs_dropentry, );//内存不足时允许丢
  3498.            } else {
  3499.                  atomic_set(&ip_vs_dropentry, );//内存足时不用丢
  3500. ;
  3501.            }
  3502.            break;
  3503. :
  3504.            atomic_set(&ip_vs_dropentry, );//允许丢
  3505.            break;
  3506.       }
  3507.       spin_unlock(&__ip_vs_dropentry_lock);
  3508.  
  3509.       spin_lock(&__ip_vs_droppacket_lock);
  3510.       switch (sysctl_ip_vs_drop_packet) {//丢包率策略
  3511. :
  3512.             ip_vs_drop_rate = ;//不用丢
  3513.             break;
  3514. :
  3515.             if (nomem) {//没内存时根据当前内存情况计算丢包率
  3516.                   ip_vs_drop_rate = ip_vs_drop_counter = sysctl_ip_vs_amemthresh / (sysctl_ip_vs_amemthresh-availmem);
  3517.                   sysctl_ip_vs_drop_packet = ;//更改丢包策略
  3518.             } else {
  3519.                   ip_vs_drop_rate = ;//不用丢
  3520.             }
  3521.             break;
  3522. :
  3523.             if (nomem) {//没内存时根据当前内存情况计算丢包率
  3524.                   ip_vs_drop_rate = ip_vs_drop_counter = sysctl_ip_vs_amemthresh / (sysctl_ip_vs_amemthresh-availmem);
  3525.             } else {
  3526.                   ip_vs_drop_rate = ;//不用丢
  3527.                   sysctl_ip_vs_drop_packet = ;
  3528.             }
  3529.             break;
  3530. :
  3531.             ip_vs_drop_rate = sysctl_ip_vs_am_droprate;//丢包率设为用户设置的丢包率
  3532.             break;
  3533.       }
  3534.       spin_unlock(&__ip_vs_droppacket_lock);
  3535.  
  3536.       write_lock(&__ip_vs_securetcp_lock);
  3537.       switch (sysctl_ip_vs_secure_tcp) {//安全TCP参数
  3538. :
  3539. )//原模式是安全模式,不改
  3540. ;
  3541.             break;
  3542. :
  3543.             if (nomem) {
  3544. )//原模式非安全模式,改变
  3545. ;
  3546.                   sysctl_ip_vs_secure_tcp = ;
  3547.             } else {
  3548. )
  3549.                         to_change = ;
  3550.             }
  3551.             break;
  3552. :
  3553.             if (nomem) {
  3554. )//原模式非安全模式,改变
  3555. ;
  3556.             } else {
  3557.                   )
  3558.                         to_change = ;
  3559.                   sysctl_ip_vs_secure_tcp = ;
  3560.             }
  3561.             break;
  3562. :
  3563. )//原模式非安全模式,改变
  3564. ;
  3565.             break;
  3566.       }
  3567.       old_secure_tcp = sysctl_ip_vs_secure_tcp;//保存上次的安全TCP参数
  3568. )//改变tcp状态超时值
  3569. );
  3570.       write_unlock(&__ip_vs_securetcp_lock);
  3571.       local_bh_enable();
  3572. }
  3573. /proc/net/ip_vs       ：IPVS的规则表
  3574. /proc/net/ip_vs_app  ：IPVS应用协议
  3575. /proc/net/ip_vs_conn ：IPVS当前连接
  3576. /proc/net/ip_vs_stats ：IPVS状态统计信息
  3577.  
  3578. ipvsadm 的用法和格式如下：
  3579.   ipvsadm COMMAND [protocol] service-address [scheduling-method] [persistence options]
  3580.   ipvsadm command [protocol] service-address server-address [packet-forwarding-method] [weight options]
  3581.  
  3582.   command:
  3583. ipvsadm -A|E -t|u|f virutal-service-address:port [-s scheduler] [-p [timeout]] [-M netmask]
  3584. ipvsadm -D -t|u|f virtual-service-address
  3585. ipvsadm -C
  3586. ipvsadm -R
  3587. ipvsadm -S [-n]
  3588. ipvsadm -a|e -t|u|f service-address:port -r real-server-address:port [-g|i|m] [-w weight]
  3589. ipvsadm -d -t|u|f service-address -r server-address
  3590. ipvsadm -L|l [options]
  3591. ipvsadm -Z [-t|u|f service-address]
  3592. ipvsadm --set tcp tcpfin udp
  3593. ipvsadm --start-daemon state [--mcast-interface interface]
  3594. ipvsadm --stop-daemon
  3595. ipvsadm –h
  3596. 术语：
  3597. virtual-service-address:是指虚拟服务器的ip 地址；
  3598. real-service-address:是指真实服务器的ip 地址；
  3599. scheduler：调度方法。
  3600. 命令选项解释：
  3601. 有两种命令选项格式，长的和短的，具有相同的意思。在实际使用时，两种都可以。
  3602. -A --add-service 在内核的虚拟服务器表中添加一条新的虚拟服务器记录。也就是增加一台新的虚拟服务器。
  3603. -E --edit-service 编辑内核虚拟服务器表中的一条虚拟服务器记录。
  3604. -D --delete-service 删除内核虚拟服务器表中的一条虚拟服务器记录。
  3605. -C --clear 清除内核虚拟服务器表中的所有记录。
  3606. -R --restore 恢复虚拟服务器规则
  3607. -S --save 保存虚拟服务器规则，输出为-R 选项可读的格式
  3608. -a --add-server 在内核虚拟服务器表的一条记录里添加一条新的真实服务器
  3609. 记录。也就是在一个虚拟服务器中增加一台新的真实服务器
  3610. -e --edit-server 编辑一条虚拟服务器记录中的某条真实服务器记录
  3611. -d --delete-server 删除一条虚拟服务器记录中的某条真实服务器记录
  3612. -L|-l --list 显示内核虚拟服务器表
  3613. -Z --zero 虚拟服务表计数器清零（清空当前的连接数量等）
  3614. --set tcp tcpfin udp 设置连接超时值timeout value: tcp, tcp FIN packet, udp
  3615. --start-daemon state启动同步守护进程。state可以是master 或backup，用来说明LVS Router 是master 或是backup。在这个功能上也可以采用keepalived 的VRRP 功能。
  3616. --stop-daemon 停止同步守护进程
  3617. -h --help 显示帮助信息
  3618.     其他的选项:
  3619. -t --tcp-service service-address 说明虚拟服务器提供的是tcp 的服务
  3620. [vip:port] or [real-server-ip:port] port为0时且有-p timeout 时接受任何端口。
  3621. -u --udp-service service-address 说明虚拟服务器提供的是udp 的服务
  3622. [vip:port] or [real-server-ip:port]
  3623. -f --fwmark-service fwmark 说明是经过iptables 标记过的服务类型firewall-mark。
  3624. -s --scheduler scheduling-method 使用的调度算法，有这样几个选项
  3625. rr|wrr|lc|wlc|lblc|lblcr|dh|sh|sed|nq, 默认的调度算法是：wlc.
  3626. Round Robin; Weighted Round-Robin; Least-Connection; Weighted Least-Connection; Locality-Based Least Connections; Locality-Based Least Connections with Replication; Destination Hashing; Source Hashing; Shortest Expected Delay; Never Queue。
  3627. -p --persistent [timeout] 持久稳固的服务。这个选项的意思是来自同一个客
  3628. 户的多次请求，将被同一台真实的服务器处理。timeout 的默认值为300 秒。
  3629. -M --netmask netmask persistent granularity mask
  3630. -r --real-server server-address 真实的服务器[Real-Server:port]
  3631. packet-forwarding-method:
  3632. -g --gatewaying 指定LVS 的工作模式为直接路由模式（也是LVS 默认的模式）
  3633. -i --ipip 指定LVS 的工作模式为隧道模式
  3634. -m --masquerading 指定LVS 的工作模式为NAT 模式
  3635. -w --weight weight 真实服务器的权值0~65535默认为1
  3636. --mcast-interface interface 指定组播的同步接口
  3637. -c --connection 显示LVS 目前的连接 如：ipvsadm -L -c
  3638. --timeout 显示tcp tcpfin udp 的timeout 值 如：ipvsadm -L --timeout
  3639. --daemon 显示同步守护进程状态
  3640. --stats 显示统计信息statistics information
  3641. --rate 显示速率信息
  3642. --sort 对虚拟服务器和真实服务器排序输出
  3643. --numeric -n 输出IP 地址和端口的数字形式
  3644. 例子：
  3645. ipvsadm –A –t  –s rr
  3646. ipvsadm –a –t  –r  –m
  3647. ipvsadm –a –t  –r  –m
  3648. ipvsadm –a –t  –r  –m
  3649. ipvsadm –a –t  –r  –m
  3650. ipvsadm –a –t  –r  –m
  3651.  
  3652. 配置IPVS Table脚本 ：
  3653. VIP=192.168.34.41   #Vritual IP地址
  3654. RIP1= IP
  3655. RIP2= IP
  3656. GW=192.168.34.1    #Real Server 网关IP
  3657. #清除IPVS Table
  3658. ipvsadm -C
  3659. #设置IPVS Table
  3660. ipvsadm -A -t $VIP: -s wlc
  3661. ipvsadm -a -t $VIP: -r $RIP1: -g -w
  3662. ipvsadm -a -t $VIP: -r $RIP2: -g -w
  3663. #将IPVS Table保存到/etc/sysconfig/ipvsadm
  3664. /etc/rc.d/init.d/ipvsadm save
  3665. #启动IPVS
  3666. service ipvsadm start    #或者/etc/rc.d/init.d/ipvsadm start也可以
  3667. #显示IPVS状态
  3668. 　　ipvsadm -l

IPVS实现分析的更多相关文章

  1. 14.深入k8s：kube-proxy ipvs及其源码分析

    转载请声明出处哦~,本篇文章发布于luozhiyun的博客:https://www.luozhiyun.com 源码版本是1.19 这一篇是讲service,但是基础使用以及基本概念由于官方实在是写的 ...

  2. Kubernetes网络的iptables模式和ipvs模式支持ping分析

    1.iptables模式无法ping通原因分析 iptables模式下,无法ping通任何svc,包括clusterip.所有ns下,下面来分析原因: 查看kubernetes的网络模式 curl 1 ...

  3. lvs源代码分析

    以linux-2.6.21为例. 数据结构介绍: ip_vs_conn 对于某个连接记录其N元组, (client, vserver, rserver) & (address, port) Q ...

  4. Mini2440 DM9000 驱动分析（一）

    Mini2440 DM9000 驱动分析(一) 硬件特性 Mini2440开发板上DM9000的电气连接和Mach-mini2440.c文件的关系: PW_RST 连接到复位按键,复位按键按下,低电平 ...

  5. 应用负载均衡之LVS(三)：使用ipvsadm以及详细分析VS/DR模式

    */ .hljs { display: block; overflow-x: auto; padding: 0.5em; color: #333; background: #f8f8f8; } .hl ...

  6. 抓包分析LVS-NAT中出现的SYN_RECV

    CIP:192.168.10.193 VIP:192.168.10.152:8000 DIP:100.10.8.152:8000 RIP:100.10.8.101:8000 和 100.10.8.10 ...

  7. 为什么比IPVS的WRR要好？

    动机 五一临近,四月也接近尾声,五一节乃小长假的最后一天.今天是最后一天工作日,竟然感冒了,半夜里翻来覆去无法安睡,加上窗外大飞机屋里小飞机(也就是蚊子)的骚扰,实在是必须起来做点有意义的事了!    ...

  8. IPVS和Nginx两种WRR负载均衡算法详解

    动机 五一临近,四月也接近尾声,五一节乃小长假的最后一天.今天是最后一天工作日,竟然感冒了,半夜里翻来覆去无法安睡,加上窗外大飞机屋里小飞机(也就是蚊子)的骚扰,实在是必须起来做点有意义的事了!    ...

  9. 【linux驱动分析】之dm9000驱动分析（三）：sk_buff结构分析

    [linux驱动分析]之dm9000驱动分析(一):dm9000原理及硬件分析 [linux驱动分析]之dm9000驱动分析(二):定义在板文件里的资源和设备以及几个宏 [linux驱动分析]之dm9 ...

随机推荐

  1. SQL Server 2008 TOP 新用途

    /***************创建测试表******************************/ IF NOT OBJECT_ID('[Demo_Top]') IS NULL DROP TAB ...

  2. 20151214 jquery插件代码备份

    ;(function ($) { //局部性的 /*$.fn.extend({ 'nav' : function (color) { $(this).find('.nav').css({ 'list- ...

  3. Tomcat中JSP引擎工作原理

    http://blog.csdn.net/linjiaxingqqqq/article/details/7164449 JSP运行环境: 执行JSP代码需要在服务器上安装JSP引擎,比较常见的引擎有W ...

  4. Java之反射的应用

      package com.zheges; import java.util.Date; public class Customer {//JavaBean 对象 private String nam ...

  5. 命令行下上传文件到iOS软件 专业文件管理/gplayer

    U盘丢了, 就拿手机当U盘用用先. 一般情况下软件打开上传功能, 在浏览器里上传即可. 可是偏偏我的电影放在了 树莓派里面(搭建了一个SMB), 直接浏览器的话,会多占用些带宽, 我的破路由器.... ...

  6. 关于Navicat导入MySQL数据库遇到的一些问题

    今天本想将之前的一个数据库easy.sql用图形化工具Navicat导入的,开始是用“运行SQL文件”导入,结果是“queries successfully”啥的,去查是否导表成功,一看并没有. 结果 ...

  7. [开发环境] Ubuntu12.04 Telnet服务设置

    Ubuntu12.04默认未启用Telnet服务,配置Telnet服务步骤如下: 1. 安装和配置 安装openbsd-inetd: #sudo apt-get install openbsd-ine ...

  8. MySQL数据库原理

    我们知道,数据是信息的载体——一种我们约定了如何解释的符号.在计算机系统中,最常见的应该是文本数据.我们用它记录配置信息,写日志,等等.而在应用程序中,按一定的数据结构来组织数据的方式叫做数据库管理系 ...

  9. express开发实例

    express获取参数有三种方法:官网介绍如下 Checks route params (req.params), ex: /user/:id Checks query string params ( ...

  10. Couldn't get lock for %t/vertx.log

    今天在启动vertx框架的项目时,报“Couldn't get lock for %t/vertx.log”的错误. 解决方案: 1,找出vertx.log的目录.一般在(C:\Users\Admin ...