net/ipv4/ipvs/ip_vs_core.c
 /*
  *    Initialize IP Virtual Server
  */
 static int __init ip_vs_init(void)
 {
     int ret;
                                 //登记ipvs的sockopt控制,这样用户空间可通过
     ret = ip_vs_control_init(); //setsockopt函数来和ipvs进行通信.
     if (ret < 0) {
         IP_VS_ERR("can't setup control.\n");
         goto cleanup_nothing;
     }
                             //初始化ipvs能支持的协议,
     ip_vs_protocol_init();  //一共4个(tcp/udp/ha/esp),使用了双向链表结构
  
     ret = ip_vs_app_init(); //应用层辅助协议初始化
     if (ret < 0) {            
         IP_VS_ERR("can't setup application helper.\n");
         goto cleanup_protocol;
     }
  
     ret = ip_vs_conn_init();        //初始化ipvs连接
     if (ret < 0) {
         IP_VS_ERR("can't setup connection table.\n");
         goto cleanup_app;
     }
                                     //注册hook函数
     ret = nf_register_hooks(ip_vs_ops, ARRAY_SIZE(ip_vs_ops));
     if (ret < 0) {
         IP_VS_ERR("can't register hooks.\n");
         goto cleanup_conn;
     }
  
     IP_VS_INFO("ipvs loaded.\n");
     return ret;
  
   cleanup_conn:
     ip_vs_conn_cleanup();       //清除ip_vs_conn_init()产生的连接参数
   cleanup_app:
     ip_vs_app_cleanup();        //清除ip_vs_app_init()产生的参数
   cleanup_protocol:
     ip_vs_protocol_cleanup();   //清除ip_vs_protocol_init()产生的参数
     ip_vs_control_cleanup();    //..
   cleanup_nothing:
     return ret;
 }

net/ipv4/ipvs/ip_vs_ctl.c
 int ip_vs_control_init(void)
 {
     int ret;
     int idx;
  
     EnterFunction(2);   //如果开启了debug功能,EnterFunction()函数将显示debug信息 
  
     ret = nf_register_sockopt(&ip_vs_sockopts); //注册ip_vs_sockopts[]内的opt,这样用户空间可通过setsockopt()/getsockopt()函数来和ipvs通讯
     if (ret) {
         IP_VS_ERR("cannot register sockopt.\n");
         return ret;
     }
     
     proc_net_fops_create(&init_net, "ip_vs", 0, &ip_vs_info_fops);  //建立/proc/net/ip_vs和/proc/net/ip_vs_stats只读项,便于读取ipvs信息
     proc_net_fops_create(&init_net, "ip_vs_stats",0, &ip_vs_stats_fops);
  
     sysctl_header = register_sysctl_paths(net_vs_ctl_path, vs_vars);    //建立/proc/sys/net/ipv4/vs目录下的各可读写控制参数,路径由net_vs_ctl_path定义,文件个数以及文件的参数由vs_vars定义 
  
     /* Initialize ip_vs_svc_table, ip_vs_svc_fwm_table, ip_vs_rtable */
     for(idx = 0; idx < IP_VS_SVC_TAB_SIZE; idx++)  {
         INIT_LIST_HEAD(&ip_vs_svc_table[idx]);      //创建并初始化ip_vs_svc_table[255],用户通过协议/地址/端口信息来查找vs服务信息的hash双向链表
         INIT_LIST_HEAD(&ip_vs_svc_fwm_table[idx]);  //同上
     }
     for(idx = 0; idx < IP_VS_RTAB_SIZE; idx++)  {
         INIT_LIST_HEAD(&ip_vs_rtable[idx]);         //创建并初始化ip_vs_rtable[16],用户通过协议/地址/端口信息来查找目的rs主机信息的hash双向链表
     }
  
     memset(&ip_vs_stats, 0, sizeof(ip_vs_stats));   //将ip_vs_stats指向的空间用0填充,相当于初始化ip_vs_stats,
     spin_lock_init(&ip_vs_stats.lock);              //ip_vs_stats的结构在ip_vs.h中定义,为全局变量,内部存放了vs(虚拟服务)的状态(接受/发送的数据包/数据量/速率等信息,以及一个自旋锁
     ip_vs_new_estimator(&ip_vs_stats);              //对ip_vs_stats建立一个预估器,可用于计算服务器的性能参数.相当于从ip_vs_stats复制了一份状态信息到est_list循环单向链表
 // est_list -> est.next -> set.next -> est_list
     /* Hook the defense timer */
     schedule_delayed_work(&defense_work, DEFENSE_TIMER_PERIOD);
 //延迟调度工作, 延迟一定时间后再将工作结构挂接到工作队列,加入的任务defense_work好像是空的,由DECLARE_DELAYED_WORK(defense_work, defense_work_handler)初始化完成,DECLARE_DELAYED_WORK() -> __DELAYED_WORK_INITIALIZER -> __WORK_INITIALIZER(TIMER_INITIALIZER) -> __WORK_INITIALIZER -> __WORK_INIT_LOCKDEP_MAP 
     LeaveFunction(2);      //报告一个debug信息,最后返回0,用来表示函数正常结束
     return 0;
 }

net/ipv4/ipvs/ip_vs_ctl.c
 static int
 do_ip_vs_get_ctl(struct sock *sk, int cmd, void __user *user, int *len)
 {
     unsigned char arg[128];     //用来存放用户空间的参数
     int ret = 0;
  
     if (!capable(CAP_NET_ADMIN))    //判断是否有管理员权限
         return -EPERM;
  
     if (*len < get_arglen[GET_CMDID(cmd)]) {    //判断参数长度是否异常
         IP_VS_ERR("get_ctl: len %u < %u\n",
               *len, get_arglen[GET_CMDID(cmd)]);
         return -EINVAL;
     }
  
     if (copy_from_user(arg, user, get_arglen[GET_CMDID(cmd)]) != 0) //内核空间不能直接访问用户空间的user变量,需要copy_from_user()函数将参数拷贝到arg内
         return -EFAULT;
  
     if (mutex_lock_interruptible(&__ip_vs_mutex))   //得到互斥锁,上锁
         return -ERESTARTSYS;
  
     switch (cmd) {  //根据不同的get动作,调用相应的函数
     case IP_VS_SO_GET_VERSION:
     {
         char buf[64];
  
         sprintf(buf, "IP Virtual Server version %d.%d.%d (size=%d)",  //将ipvs的版本存入buf内
             NVERSION(IP_VS_VERSION_CODE), IP_VS_CONN_TAB_SIZE);
         if (copy_to_user(user, buf, strlen(buf)+1) != 0) {      //使用copy_to_user将buf的内容拷贝到用户空间的user变量
             ret = -EFAULT;
             goto out;
         }
         *len = strlen(buf)+1;
     }
     break;
  
     case IP_VS_SO_GET_INFO: //获得版本信息
     {
         struct ip_vs_getinfo info;
         info.version = IP_VS_VERSION_CODE;
         info.size = IP_VS_CONN_TAB_SIZE;
         info.num_services = ip_vs_num_services;
         if (copy_to_user(user, &info, sizeof(info)) != 0)
             ret = -EFAULT;
     }
     break;
  
     case IP_VS_SO_GET_SERVICES: //获得多个服务器规则信息
     {
         struct ip_vs_get_services *get;
         int size;
  
         get = (struct ip_vs_get_services *)arg; //做一个类型转换给get
         size = sizeof(*get) +
             sizeof(struct ip_vs_service_entry) * get->num_services; //得到get指向变量的大小
         if (*len != size) {                 //比较size的大小,如果于len不等,退出
             IP_VS_ERR("length: %u != %u\n", *len, size);
             ret = -EINVAL;
             goto out;
         }
         ret = __ip_vs_get_service_entries(get, user);   //依次得到get指向vs服务(多个)的规则信息,用ip_vs_copy_service()/ip_vs_copy_stats()复制变量,然后用copy_to_user()将其拷贝到用户空间,其中大量用到memcpy()
     }
     break;
  
     case IP_VS_SO_GET_SERVICE:  //得到一个vs服务的规则信息
     {
         struct ip_vs_service_entry *entry;
         struct ip_vs_service *svc;
  
         entry = (struct ip_vs_service_entry *)arg;
         if (entry->fwmark)                              //如果有firwall,则通过掩码得到vs服务指针svc
             svc = __ip_vs_svc_fwm_get(entry->fwmark);
         else                                            //否则通过协议/地址/端口得到vs服务指针svc
             svc = __ip_vs_service_get(entry->protocol,
                           entry->addr, entry->port);
         if (svc) {
             ip_vs_copy_service(entry, svc);             //将svc的内容复制给entry
             if (copy_to_user(user, entry, sizeof(*entry)) != 0) //将entry的内容复制给用户空间变量user
                 ret = -EFAULT;
             ip_vs_service_put(svc);
         } else
             ret = -ESRCH;
     }
     break;
  
     case IP_VS_SO_GET_DESTS:        //得到多个rs服务信息
     {
         struct ip_vs_get_dests *get;
         int size;
  
         get = (struct ip_vs_get_dests *)arg;
         size = sizeof(*get) +
             sizeof(struct ip_vs_dest_entry) * get->num_dests;
         if (*len != size) {
             IP_VS_ERR("length: %u != %u\n", *len, size);
             ret = -EINVAL;
             goto out;
         }
         ret = __ip_vs_get_dest_entries(get, user);  //复制到用户空间
     }
     break;
  
     case IP_VS_SO_GET_TIMEOUT:  //获取超时信息
     {
         struct ip_vs_timeout_user t;
  
         __ip_vs_get_timeouts(&t);
         if (copy_to_user(user, &t, sizeof(t)) != 0)
             ret = -EFAULT;
     }
     break;
  
     case IP_VS_SO_GET_DAEMON:       //获取IPVS内核守护进程信息结构
     {
         struct ip_vs_daemon_user d[2];
  
         memset(&d, 0, sizeof(d));
         if (ip_vs_sync_state & IP_VS_STATE_MASTER) {
             d[0].state = IP_VS_STATE_MASTER;
             strlcpy(d[0].mcast_ifn, ip_vs_master_mcast_ifn, sizeof(d[0].mcast_ifn));
             d[0].syncid = ip_vs_master_syncid;
         }
         if (ip_vs_sync_state & IP_VS_STATE_BACKUP) {
             d[1].state = IP_VS_STATE_BACKUP;
             strlcpy(d[1].mcast_ifn, ip_vs_backup_mcast_ifn, sizeof(d[1].mcast_ifn));
             d[1].syncid = ip_vs_backup_syncid;
         }
         if (copy_to_user(user, &d, sizeof(d)) != 0)
             ret = -EFAULT;
     }
     break;
  
     default:
         ret = -EINVAL;
     }
  
   out:
     mutex_unlock(&__ip_vs_mutex);       //解锁
     return ret;
 }

net/ipv4/ipvs/ip_vs_ctl.c
 static int
 do_ip_vs_set_ctl(struct sock *sk, int cmd, void __user *user, unsigned int len)
 {
     int ret;
     unsigned char arg[MAX_ARG_LEN];
     struct ip_vs_service_user *usvc;
     struct ip_vs_service *svc;
     struct ip_vs_dest_user *udest;
  
     if (!capable(CAP_NET_ADMIN))
         return -EPERM;
  
     if (len != set_arglen[SET_CMDID(cmd)]) {    //检查len准确性
         IP_VS_ERR("set_ctl: len %u != %u\n",
               len, set_arglen[SET_CMDID(cmd)]);
         return -EINVAL;
     }
  
     if (copy_from_user(arg, user, len) != 0)    //将用户空间的user变量内容复制给arg变量
         return -EFAULT;
  
     /* increase the module use count */
     ip_vs_use_count_inc();      //ipvs使用计数器+1
  
     if (mutex_lock_interruptible(&__ip_vs_mutex)) { //给ipvs上锁
         ret = -ERESTARTSYS;
         goto out_dec;
     }
  
     if (cmd == IP_VS_SO_SET_FLUSH) {
         /* Flush the virtual service */
         ret = ip_vs_flush();
         goto out_unlock;
     } else if (cmd == IP_VS_SO_SET_TIMEOUT) {
         /* Set timeout values for (tcp tcpfin udp) */
         ret = ip_vs_set_timeout((struct ip_vs_timeout_user *)arg);
         goto out_unlock;
     } else if (cmd == IP_VS_SO_SET_STARTDAEMON) {       //开启守护进程
         struct ip_vs_daemon_user *dm = (struct ip_vs_daemon_user *)arg;
         ret = start_sync_thread(dm->state, dm->mcast_ifn, dm->syncid);
         goto out_unlock;
     } else if (cmd == IP_VS_SO_SET_STOPDAEMON) {        //关闭守护进程
         struct ip_vs_daemon_user *dm = (struct ip_vs_daemon_user *)arg;
         ret = stop_sync_thread(dm->state);
         goto out_unlock;
     }
  
     usvc = (struct ip_vs_service_user *)arg;        //将usvc指向arg,并将类型转化为ip_vs_service_user
     udest = (struct ip_vs_dest_user *)(usvc + 1);   //将udest类型转化为ip_vs_dest_user,并指向usvc的后一个单位
  
     if (cmd == IP_VS_SO_SET_ZERO) {         //如果是归零操作,先查看是否是对于某个指定服务的,如果不是,则全部清零
         /* if no service address is set, zero counters in all */
         if (!usvc->fwmark && !usvc->addr && !usvc->port) {
             ret = ip_vs_zero_all();
             goto out_unlock;
         }
     }
  
     /* Check for valid protocol: TCP or UDP, even for fwmark!=0 */
     if (usvc->protocol!=IPPROTO_TCP && usvc->protocol!=IPPROTO_UDP) {   //如果usvc协议类型不是tcp/udp,则跳至out_unlock
         IP_VS_ERR("set_ctl: invalid protocol: %d %d.%d.%d.%d:%d %s\n",
               usvc->protocol, NIPQUAD(usvc->addr),
               ntohs(usvc->port), usvc->sched_name);
         ret = -EFAULT;
         goto out_unlock;
     }
  
     /* Lookup the exact service by <protocol, addr, port> or fwmark */
     if (usvc->fwmark == 0)                          //如果fwmark为0,通过协议,地址,端口的hash值到ip_vs_svc_table[]双向链表里寻找相应的svc
         svc = __ip_vs_service_get(usvc->protocol,
                       usvc->addr, usvc->port);
     else                                            //否则通过fwmark的hash值到ip_vs_svc_fwm_table[]双向链表里寻找相应的svc
         svc = __ip_vs_svc_fwm_get(usvc->fwmark);
  
     if (cmd != IP_VS_SO_SET_ADD     //不是添加规则时,而且svc没有找到或者于vsvc的协议类型不符,则跳至out_unlock
         && (svc == NULL || svc->protocol != usvc->protocol)) {
         ret = -ESRCH;
         goto out_unlock;
     }
  
     switch (cmd) {
     case IP_VS_SO_SET_ADD:      //添加服务器规则(svc)
         if (svc != NULL)
             ret = -EEXIST;
         else
             ret = ip_vs_add_service(usvc, &svc); //该函数会判断svc是否已存在,如果不存在,会将svc添加到相应hash值的列表中(ip_vs_svc_fwm_table[]和ip_vs_svc_table[])
         break;
     case IP_VS_SO_SET_EDIT:     //编辑
         ret = ip_vs_edit_service(svc, usvc);
         break;
     case IP_VS_SO_SET_DEL:      //删除
         ret = ip_vs_del_service(svc);
         if (!ret)
             goto out_unlock;
         break;
     case IP_VS_SO_SET_ZERO:     //将特定svc计数清零
         ret = ip_vs_zero_service(svc);
         break;
     case IP_VS_SO_SET_ADDDEST:  //将rs服务器信息添加到ip_vs_rtable[],svc->destinations中
         ret = ip_vs_add_dest(svc, udest);
         break;
     case IP_VS_SO_SET_EDITDEST: //编辑rs服务器信息
         ret = ip_vs_edit_dest(svc, udest);
         break;
     case IP_VS_SO_SET_DELDEST:  //将rs服务器信息从svc->destinations中删除
         ret = ip_vs_del_dest(svc, udest);
         break;
     default:
         ret = -EINVAL;
     }
  
     if (svc)
         ip_vs_service_put(svc); //svc使用完毕,释放svc使用计数
  
   out_unlock:
     mutex_unlock(&__ip_vs_mutex);       //ipvs解锁
   out_dec:
     /* decrease the module use count */
     ip_vs_use_count_dec();      //ipvs使用完毕,释放ipvs计数器
  
     return ret;
 }

net/ipv4/ipvs/ip_vs_proto.c
 int ip_vs_protocol_init(void)
 {
     char protocols[64];
 #define REGISTER_PROTOCOL(p)            \       //用来注册协议的宏
     do {                    \
         register_ip_vs_protocol(p);    \           //注册协议的函数
         strcat(protocols, ", ");    \           //将 ",(p)->name"添加到字符串protocols之后
         strcat(protocols, (p)->name);    \
     } while (0)
  
     protocols[0] = '\0';                        //初始化protocols
     protocols[2] = '\0';
 #ifdef CONFIG_IP_VS_PROTO_TCP
     REGISTER_PROTOCOL(&ip_vs_protocol_tcp);     //使得ipvs能支持TCP协议
 #endif
 #ifdef CONFIG_IP_VS_PROTO_UDP
     REGISTER_PROTOCOL(&ip_vs_protocol_udp);     //注册UDP协议
 #endif
 #ifdef CONFIG_IP_VS_PROTO_AH
     REGISTER_PROTOCOL(&ip_vs_protocol_ah);      //注册AH(认证头)协议
 #endif
 #ifdef CONFIG_IP_VS_PROTO_ESP
     REGISTER_PROTOCOL(&ip_vs_protocol_esp);     //注册ESP(封装安全载荷)协议
 #endif
     IP_VS_INFO("Registered protocols (%s)\n", &protocols[2]);
     //debug信息,从protocols的第2个字符开始输出
     return 0;
 }

net/ipv4/ipvs/ip_vs_proto_tcp.c
 struct ip_vs_protocol ip_vs_protocol_tcp = {
     .name =            "TCP",
     .protocol =        IPPROTO_TCP,
     .num_states =        IP_VS_TCP_S_LAST,   //协议的状态,比如ESTABLISHED/LISTEN/LAST等
     .dont_defrag =        0,      //禁止重组***,ah/esp=1,tcp/udp=0
     .appcnt =        ATOMIC_INIT(0), //连接数
     .init =            ip_vs_tcp_init, //协议初始化的函数名
     .exit =            ip_vs_tcp_exit, //协议退出时的函数名
     .register_app =        tcp_register_app,   //注册函数
     .unregister_app =    tcp_unregister_app, //注销函数
     .conn_schedule =    tcp_conn_schedule,  //建立连接函数
     .conn_in_get =        tcp_conn_in_get,    //
     .conn_out_get =        tcp_conn_out_get,   //
     .snat_handler =        tcp_snat_handler,   //snat
     .dnat_handler =        tcp_dnat_handler,   //dnat
     .csum_check =        tcp_csum_check,     //
     .state_name =        tcp_state_name,     //
     .state_transition =    tcp_state_transition,   //
     .app_conn_bind =    tcp_app_conn_bind,      //
     .debug_packet =        ip_vs_tcpudp_debug_packet,  //
     .timeout_change =    tcp_timeout_change,         //
     .set_state_timeout =    tcp_set_state_timeout,  //
 };

net/ipv4/ipvs/ip_vs_proto.c
 /*
  *    register an ipvs protocol
  */
 static int __used register_ip_vs_protocol(struct ip_vs_protocol *pp)
 {
     unsigned hash = IP_VS_PROTO_HASH(pp->protocol); //用pp->protocol(u16)算出hashkey
  
     pp->next = ip_vs_proto_table[hash]; //将pp插入到ip_vs_proto_table[hash]之后
     ip_vs_proto_table[hash] = pp;       //ip_vs_proto_table[hash]是一个单向链表
  
     if (pp->init != NULL)               //如果该协议定义了初始化函数,运行之
         pp->init(pp);
  
     return 0;
 }

net/ipv4/ipvs/ip_vs_proto.c
 /*
  * IPVS protocols can only be registered/unregistered when the ipvs
  * module is loaded/unloaded, so no lock is needed in accessing the
  * ipvs protocol table.
  */
  
 #define IP_VS_PROTO_TAB_SIZE        32    /* must be power of 2 */
 #define IP_VS_PROTO_HASH(proto)        ((proto) & (IP_VS_PROTO_TAB_SIZE-1))
  
 static struct ip_vs_protocol *ip_vs_proto_table[IP_VS_PROTO_TAB_SIZE];

net/ipv4/ipvs/ip_vs_proto_tcp.c
 static void ip_vs_tcp_init(struct ip_vs_protocol *pp)
 {
     IP_VS_INIT_HASH_TABLE(tcp_apps);    //初始化tcp_apps[16]双向链表数组
     pp->timeout_table = tcp_timeouts;   //超时列表赋值
 }

net/ipv4/ipvs/ip_vs_app.c
 int ip_vs_app_init(void)
 {
     /* we will replace it with proc_net_ipvs_create() soon */
     proc_net_fops_create(&init_net, "ip_vs_app", 0, &ip_vs_app_fops);   //建立/proc/net/ip_vs_app只读项
     return 0;
 }

net/ipv4/ipvs/ip_vs_conn.c
 int ip_vs_conn_init(void)
 {
     int idx;
  
     /*
      * Allocate the connection hash table and initialize its list heads
      */
     ip_vs_conn_tab = vmalloc(IP_VS_CONN_TAB_SIZE*sizeof(struct list_head));
     if (!ip_vs_conn_tab)        //CONFIG_IP_VS_TAB_BITS会参照CONFIG_IP_VS_TAB_BITS的数值,但在[8,20]之间浮动
         return -ENOMEM;         //为记录连接信息分配列表存储空间
  
     /* Allocate ip_vs_conn slab cache *///这里是在系统的缓存区注册一个ip_vs_conn_cachep类型的内存池,一个单位大小就是sizeof(struct ip_vs_conn),如果需要分配一个内存空间,可以用kmem_cache_zalloc()来分配一个单位大小,具体实现在mm/slab.c里
     ip_vs_conn_cachep = kmem_cache_create("ip_vs_conn", 
                           sizeof(struct ip_vs_conn), 0,
                           SLAB_HWCACHE_ALIGN, NULL);
     if (!ip_vs_conn_cachep) {
         vfree(ip_vs_conn_tab);
         return -ENOMEM;
     }
  
     IP_VS_INFO("Connection hash table configured "       //debug信息
            "(size=%d, memory=%ldKbytes)\n",
            IP_VS_CONN_TAB_SIZE,
            (long)(IP_VS_CONN_TAB_SIZE*sizeof(struct list_head))/1024);
     IP_VS_DBG(0, "Each connection entry needs %Zd bytes at least\n",
           sizeof(struct ip_vs_conn));
  
     for (idx = 0; idx < IP_VS_CONN_TAB_SIZE; idx++) {       //初始化ip_vs_conn_tab[]的双向链表结构
         INIT_LIST_HEAD(&ip_vs_conn_tab[idx]);
     }
  
     for (idx = 0; idx < CT_LOCKARRAY_SIZE; idx++)  {    //初始化array for conn table的锁结构,初始为未上锁
         rwlock_init(&__ip_vs_conntbl_lock_array[idx].l);
     }
  
     proc_net_fops_create(&init_net, "ip_vs_conn", 0, &ip_vs_conn_fops);//创建/proc/net/ipvs_conn(_sync)只读文件
     proc_net_fops_create(&init_net, "ip_vs_conn_sync", 0, &ip_vs_conn_sync_fops);
  
     /* calculate the random value for connection hash */
     get_random_bytes(&ip_vs_conn_rnd, sizeof(ip_vs_conn_rnd)); //向ip_vs_conn_rnd注入sizeof(ip_vs_conn_rnd)大小的随机信息(int类型),用来产生hash值的jhash_3words()函数会用到这个变量
  
     return 0;
 }

net/netfilter/core.c
 int nf_register_hooks(struct nf_hook_ops *reg, unsigned int n)
 {
     unsigned int i;
     int err = 0;
  
     for (i = 0; i < n; i++) {       //可以看到,这里就是将*reg数组里的每个元素一个一个的用nf_register_hook()进行注册
         err = nf_register_hook(&reg[i]);
         if (err)
             goto err;
     }
     return err;
  
 err:            //出现异常就注销
     if (i > 0)
         nf_unregister_hooks(reg, i);
     return err;
 }
 EXPORT_SYMBOL(nf_register_hooks);   //让其他模块能也能调用此函数

net/netfilter/core.c
 int nf_register_hook(struct nf_hook_ops *reg) //*reg就是将要添加到nf_hooks列表中的ops了
 {
     struct nf_hook_ops *elem;   //用来遍历数组用的临时指针
     int err;
  
     err = mutex_lock_interruptible(&nf_hook_mutex); //nf_hook_mutex变量是nf_hook的互斥锁,操作的时候先要得到锁
     if (err < 0)
         return err;
     list_for_each_entry(elem, &nf_hooks[reg->pf][reg->hooknum], list) {//遍历nf_hooks[reg->pf][reg->hooknum]->list双向链表
         if (reg->priority < elem->priority) //比较优先级,priority值越小,优先级越高.这里按照优先级由高到低的顺序插入到nf_hooks链表里
             break;
     }
     list_add_rcu(&reg->list, elem->list.prev);  //进行加入,elem->list.prev就是找到的插入点
     mutex_unlock(&nf_hook_mutex);   //释放锁
     return 0;
 }
 EXPORT_SYMBOL(nf_register_hook);