老马驿站
老马驿站

PF_RING实现分析

PF_RING实现分析
http://bbs.chinaunix.net/thread-1943951-1-1.html
版权所有，转载请注明出处

独孤九贱

内核版本：Linux 2.6.30.9

PF_RING版本：4.1.0

最近看了一个PF_RING的实现，看了个大概，发上来大家讨论讨论，共同学习。

一、什么是PF_RING
PF_RING是一个第三方的内核数据包捕获接口，类似于libpcap，它的官方网址是： http://www.ntop.org/PF_RING.html

二、为什么需要PF_RING
一切为了效率，按照其官方网站上的测试数据，在Linux平台之上，其效率至少高于libpcap 50% - 60%，甚至是一倍。更好的是，PF_RING提供了一个修改版本的libpcap，使之建立在PF_RING接口之上。这样，原来使用libpcap的程序，就可以自然过渡了。

三、声明
1、这不是“零拷贝”，研究“零拷贝”的估计要失望，如果继续看下去的话；
2、这不是包截获接口，如果需要拦截、修改内核数据包，请转向Netfilter；
3、本文只分析了PF_RING最基础的部份。关于DNA、TNAPI，BPF等内容不包含在内。

四、源码的获取
svn co  https://svn.ntop.org/svn/ntop/trunk/PF_RING/ 

最近好像全流行svn了。

五、编译和使用
接口分为两部份，一个是内核模块，一个是用户态的库
cd my_pf_ring_goes_here 
cd kernel 
make 
sudo insmod ./pf_ring.ko 
cd ../userland 
make 

在源码目录中，关于用户态的库有使用的现成的例子，很容易依葫芦画瓢。后文也会提到用户态库的实现的简单分析，可以两相比照，很容易上手。而且源码目录中有一个PDF文档，有详细的API介绍，建议使用前阅读。

六、实现分析初步
1、核心思路
A、在内核队列层注册Hook，获取数据帧。
B、在内核创建一个环形队列(这也是叫RING的原因)，用于存储数据，并使用mmap映射到用户空间。这样，避免用户态的系统调用，也是提高性能的关键所在。
C、创建了一个新的套接字类型PF_RING，用户态通过它与内核通信。

2、模块初始化
模块源码只有一个文件，在目录树kernel/pf_ring.c，嗯，还有一个头文件，在kernel/linux下
  1. static int __init ring_init(void)
  2. {
  3.   int i, rc;

  5.   printk("[PF_RING] Welcome to PF_RING %s ($Revision: 4012 $)\n"
  6.          "(C) 2004-09 L.Deri <[email][email protected][/email]>\n", RING_VERSION);
  7.         
  8.         //注册名为PF_RING的新协议
  9.   if((rc = proto_register(&ring_proto, 0)) != 0)
  10.     return(rc);
复制代码


ring_proto的定义为
  1. #if(LINUX_VERSION_CODE > KERNEL_VERSION(2,6,11))
  2. static struct proto ring_proto = {
  3.   .name = "PF_RING",
  4.   .owner = THIS_MODULE,
  5.   .obj_size = sizeof(struct ring_sock),
  6. };
  7. #endif
复制代码


初始化四个链表，它们的作用，后文会分析到：
  1.         //初始化四个链表
  2.   INIT_LIST_HEAD(&ring_table);                                        /* List of all ring sockets. */
  3.   INIT_LIST_HEAD(&ring_cluster_list);                        /* List of all clusters */
  4.   INIT_LIST_HEAD(&ring_aware_device_list);                /* List of all devices on which PF_RING has been registered */
  5.   INIT_LIST_HEAD(&ring_dna_devices_list);                /* List of all dna (direct nic access) devices */
复制代码


device_ring_list是一个指针数组，它的每一个元素对应一个网络设备，后文也会分析它的使用：
  1. /*
  2.   For each device, pf_ring keeps a list of the number of
  3.   available ring socket slots. So that a caller knows in advance whether
  4.   there are slots available (for rings bound to such device)
  5.   that can potentially host the packet
  6. */
  7.   for (i = 0; i < MAX_NUM_DEVICES; i++)
  8.     INIT_LIST_HEAD(&device_ring_list[i]);
复制代码

  1.         //为新协议注册sock
  2.   sock_register(&ring_family_ops);
复制代码


ring_family_ops定义为
  1. static struct net_proto_family ring_family_ops = {
  2.   .family = PF_RING,
  3.   .create = ring_create,
  4.   .owner = THIS_MODULE,
  5. };
复制代码

这样，当用户空间创建PF_RING时，例如，
  1. fd = socket(PF_RING, SOCK_RAW, htons(ETH_P_ALL));
复制代码

ring_create将会被调用

  1.   //注册通知链表  
  2.   register_netdevice_notifier(&ring_netdev_notifier);

  4.   /* 工作模式语法检查 */
  5.   if(transparent_mode > driver2pf_ring_non_transparent)
  6.     transparent_mode = standard_linux_path;
复制代码


PF_RING一共有三种工作模式：
  1. typedef enum {
  2.   standard_linux_path = 0, /* Business as usual */
  3.   driver2pf_ring_transparent = 1, /* Packets are still delivered to the kernel */
  4.   driver2pf_ring_non_transparent = 2 /* Packets not delivered to the kernel */
  5. } direct2pf_ring;
复制代码

第一种最简单，这里仅分析第一种

  1.         //输出工作信息参数
  2.   printk("[PF_RING] Ring slots       %d\n", num_slots);
  3.   printk("[PF_RING] Slot version     %d\n",
  4.          RING_FLOWSLOT_VERSION);
  5.   printk("[PF_RING] Capture TX       %s\n",
  6.          enable_tx_capture ? "Yes [RX+TX]" : "No [RX only]");
  7.   printk("[PF_RING] Transparent Mode %d\n",
  8.          transparent_mode);
  9.   printk("[PF_RING] IP Defragment    %s\n",
  10.          enable_ip_defrag ? "Yes" : "No");
  11.   printk("[PF_RING] Initialized correctly\n");
复制代码


num_slots为槽位总数，系统采用数组来实现双向环形队列，它也就代表数组的最大元素。
版本信息：不用多说了。不过我的版本在2.6.18及以下都没有编译成功，后来使用2.6.30.9搞定之。
enable_tx_capture：是否启用发送时的数据捕获，对于大多数应用而言，都是在接收时处理。
enable_ip_defrag：为用户提供一个接口，是否在捕获最重组IP分片。

  1.         //创建/proc目录
  2.   ring_proc_init();
  3.   
  4.   //注册设备句柄
  5.   register_device_handler();

  7.   pfring_enabled = 1;                //工作标志
  8.   return 0;
  9. }
复制代码


register_device_handler注册了一个协议，用于数据包的获取：
  1. /* Protocol hook */
  2. static struct packet_type prot_hook;

  4. void register_device_handler(void) {
  5.         //只有在第一种模式下，才用这种方式接收数据
  6.   if(transparent_mode != standard_linux_path) return;

  8.   prot_hook.func = packet_rcv;
  9.   prot_hook.type = htons(ETH_P_ALL);
  10.   dev_add_pack(&prot_hook);
  11. }

  13. void register_device_handler(void) {
  14.   if(transparent_mode != standard_linux_path) return;

  16.   prot_hook.func = packet_rcv;
  17.   prot_hook.type = htons(ETH_P_ALL);
  18.   dev_add_pack(&prot_hook);
  19. }
复制代码


2、创建套接字
Linux的套按字的内核接口，使用了两个重要的数据结构：
struct socket和struct sock，这本来并没有什么，不过令人常常迷惑的是，前者常常被缩写为sock，即：
struct socket *sock;
这样，“sock”就容易造成混淆了。还好，后者常常被缩写为sk……
我这里写sock指前者，sk指后者，如果不小心写混了，请参考上下文区分  。

关于这两个结构的含义，使用等等，可以参考相关资料以获取详细信息，如《Linux情景分析》。我的个人网站 www.skynet.org.cn 上也分析了Linux socket的实现。可以参考。这里关于socket的进一步信息，就不详细分析了。

这里的创建套接字，内核已经在系统调用过程中，准备好了sock，主要就是分析sk，并为sk指定一系列的操作函数，如bind、mmap、poll等等。
如前所述，套接字的创建，是通过调用ring_create函数来完成的：
  1. static int ring_create(
  2. #if(LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
  3.                        struct net *net,
  4. #endif
  5.                        struct socket *sock, int protocol)
  6. {
  7.   struct sock *sk;
  8.   struct ring_opt *pfr;
  9.   int err;

  11. #if defined(RING_DEBUG)
  12.   printk("[PF_RING] ring_create()\n");
  13. #endif

  15.   /* 权限验证 ? */
  16.   if(!capable(CAP_NET_ADMIN))
  17.     return -EPERM;

  19.   //协议簇验证
  20.   if(sock->type != SOCK_RAW)
  21.     return -ESOCKTNOSUPPORT;

  23.   //协议验证
  24.   if(protocol != htons(ETH_P_ALL))
  25.     return -EPROTONOSUPPORT;

  27.   err = -ENOMEM;

  29.   // 分配sk
  30.   // options are.
  31. #if(LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11))
  32.   sk = sk_alloc(PF_RING, GFP_KERNEL, 1, NULL);
  33. #else
  34. #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
  35.     // BD: API changed in 2.6.12, ref:
  36.     // [url]http://svn.clkao.org/svnweb/linux/revision/?rev=28201[/url]
  37.     sk = sk_alloc(PF_RING, GFP_ATOMIC, &ring_proto, 1);
  38. #else
  39.     sk = sk_alloc(net, PF_INET, GFP_KERNEL, &ring_proto);
  40. #endif
  41. #endif

  43.   //分配失败
  44.   if(sk == NULL)
  45.     goto out;
  46.   
  47.   //这里很重要，设定sock的ops，即对应用户态的bind、connect诸如此类操作的动作
  48.   sock->ops = &ring_ops;

  50.   //初始化sock结构(即sk)各成员，并设定与套接字socket(即sock)的关联
  51.   sock_init_data(sock, sk);
  52. #if(LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11))
  53.   sk_set_owner(sk, THIS_MODULE);
  54. #endif

  56.   err = -ENOMEM;

  58. #define ring_sk_datatype(__sk) ((struct ring_opt *)__sk)
  59. #define ring_sk(__sk) ((__sk)->sk_protinfo)

  61. //作者喜欢用小写的宏
  62. //这里分配一个struct ring_opt结构，这个结构比较重要，其记录了ring的选项信息。
  63. 在sk中，使用sk_protinfo成员指向之，这样就建立了sock->sk->ring_opt的关联。可以通过套接字很容易获取Ring的信息。
  64.   ring_sk(sk) = ring_sk_datatype(kmalloc(sizeof(*pfr), GFP_KERNEL));
  65.   //分配失败
  66.   if(!(pfr = ring_sk(sk))) {
  67.     sk_free(sk);
  68.     goto out;
  69.   }

  71.   //初始化各成员
  72.   memset(pfr, 0, sizeof(*pfr));
  73. //激活标志
  74.   pfr->ring_active = 0;        /* We activate as soon as somebody waits for packets */
  75.   //通道ID
  76.   pfr->channel_id = RING_ANY_CHANNEL;
  77.   //RING的每个槽位的桶的大小，其用来存储捕获的数据帧，这个值，用户态也可以使用setsocketopt来调整
  78.   pfr->bucket_len = DEFAULT_BUCKET_LEN;
  79. //过滤器hash桶
  80.   pfr->handle_hash_rule = handle_filtering_hash_bucket;
  81.   //初始化等待队列
  82.   init_waitqueue_head(&pfr->ring_slots_waitqueue);
  83.   //初始化RING的锁
  84.   rwlock_init(&pfr->ring_index_lock);
  85.   rwlock_init(&pfr->ring_rules_lock);
  86.   //初始化使用计数器
  87.   atomic_set(&pfr->num_ring_users, 0);
  88.   INIT_LIST_HEAD(&pfr->rules);
  89.   //设定协议簇
  90.   sk->sk_family = PF_RING;
  91. //设定sk的destuct函数
  92.   sk->sk_destruct = ring_sock_destruct;

  94.   //sk入队
  95.   ring_insert(sk);

  97. #if defined(RING_DEBUG)
  98.   printk("[PF_RING] ring_create() - created\n");
  99. #endif

  101.   return(0);
  102. out:
  103.   return err;
复制代码


在模块初始化中，初始化过四个链表。其中一个是ring_table，ring_insert将刚刚创建的套接字插入其中。其封装引进了一个struct ring_element 结构：
  1. /*
  2. * ring_insert()
  3. *
  4. * store the sk in a new element and add it
  5. * to the head of the list.
  6. */
  7. static inline void ring_insert(struct sock *sk)
  8. {
  9.   struct ring_element *next;
  10.   struct ring_opt *pfr;

  12. #if defined(RING_DEBUG)
  13.   printk("[PF_RING] ring_insert()\n");
  14. #endif

  16. //分配element
  17.   next = kmalloc(sizeof(struct ring_element), GFP_ATOMIC);
  18.   if(next != NULL) {
  19.     //记录sk
  20.     next->sk = sk;
  21.     write_lock_bh(&ring_mgmt_lock);
  22.     //入队
  23.     list_add(&next->list, &ring_table);
  24.     write_unlock_bh(&ring_mgmt_lock);
  25.   } else {
  26.     if(net_ratelimit())
  27.       printk("[PF_RING] net_ratelimit() failure\n");
  28.   }

  30.   //累计使用计数器
  31.   ring_table_size++;
  32.   //ring_proc_add(ring_sk(sk));
  33.   //记录进程PID
  34.   pfr = (struct ring_opt *)ring_sk(sk);
  35.   pfr->ring_pid = current->pid;
  36. }
复制代码


3 、分配队列空间
用户态在创建了套接字后，接下来就调用bind函数，绑定套接字，而PF_RING实际做的就是为RING分配相应的空间。也就是说，一个套接字，都有一个与之对应的RING。这样，有多个进程同时使用PF_RING，也没有问题:
  1.                 sa.sa_family   = PF_RING;
  2.                 snprintf(sa.sa_data, sizeof(sa.sa_data), "%s", device_name);
  3.                 rc = bind(ring->fd, (struct sockaddr *)&sa, sizeof(sa));
复制代码


因为前一步创建套接字时，为sk指定了其ops：
  1. static struct proto_ops ring_ops = {
  2.   .family = PF_RING,
  3.   .owner = THIS_MODULE,

  5.   /* Operations that make no sense on ring sockets. */
  6.   .connect = sock_no_connect,
  7.   .socketpair = sock_no_socketpair,
  8.   .accept = sock_no_accept,
  9.   .getname = sock_no_getname,
  10.   .listen = sock_no_listen,
  11.   .shutdown = sock_no_shutdown,
  12.   .sendpage = sock_no_sendpage,
  13.   .sendmsg = sock_no_sendmsg,

  15.   /* Now the operations that really occur. */
  16.   .release = ring_release,
  17.   .bind = ring_bind,
  18.   .mmap = ring_mmap,
  19.   .poll = ring_poll,
  20.   .setsockopt = ring_setsockopt,
  21.   .getsockopt = ring_getsockopt,
  22.   .ioctl = ring_ioctl,
  23.   .recvmsg = ring_recvmsg,
  24. };
复制代码


这样，当bing系统调用触发时，ring_bind函数将被调用：

  1. * Bind to a device */
  2. static int ring_bind(struct socket *sock, struct sockaddr *sa, int addr_len)
  3. {
  4.   struct sock *sk = sock->sk;
  5.   struct net_device *dev = NULL;

  7. #if defined(RING_DEBUG)
  8.   printk("[PF_RING] ring_bind() called\n");
  9. #endif

  11.   /*
  12.    *      Check legality
  13.    */
  14.   if(addr_len != sizeof(struct sockaddr))
  15.     return -EINVAL;
  16.   if(sa->sa_family != PF_RING)
  17.     return -EINVAL;
  18.   if(sa->sa_data == NULL)
  19.     return -EINVAL;

  21.   /* Safety check: add trailing zero if missing */
  22.   sa->sa_data[sizeof(sa->sa_data) - 1] = '\0';

  24. #if defined(RING_DEBUG)
  25.   printk("[PF_RING] searching device %s\n", sa->sa_data);
  26. #endif

  28.   if((dev = __dev_get_by_name(
  29. #if(LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
  30.                                &init_net,
  31. #endif
  32.                                sa->sa_data)) == NULL) {
  33. #if defined(RING_DEBUG)
  34.     printk("[PF_RING] search failed\n");
  35. #endif
  36.     return(-EINVAL);
  37.   } else
  38.     return(packet_ring_bind(sk, dev));
  39. }
复制代码


在做了一些必要的语法检查后，函数转向packet_ring_bind：
  1. /*
  2. * We create a ring for this socket and bind it to the specified device
  3. */
  4. static int packet_ring_bind(struct sock *sk, struct net_device *dev)
  5. {
  6.   u_int the_slot_len;
  7.   u_int32_t tot_mem;
  8.   struct ring_opt *pfr = ring_sk(sk);
  9.   // struct page *page, *page_end;

  11.   if(!dev)
  12.     return(-1);

  14. #if defined(RING_DEBUG)
  15.   printk("[PF_RING] packet_ring_bind(%s) called\n", dev->name);
  16. #endif

  18.   /* **********************************************

  20.    * *************************************
  21.    * *                                   *
  22.    * *        FlowSlotInfo               *
  23.    * *                                   *
  24.    * ************************************* <-+
  25.    * *        FlowSlot                   *   |
  26.    * *************************************   |
  27.    * *        FlowSlot                   *   |
  28.    * *************************************   +- num_slots
  29.    * *        FlowSlot                   *   |
  30.    * *************************************   |
  31.    * *        FlowSlot                   *   |
  32.    * ************************************* <-+
  33.    *
  34.    * ********************************************** */

  36.         //计算每一个槽位所需的内存空间
  37.   the_slot_len = sizeof(u_char)        /* flowSlot.slot_state */
  38. #ifdef RING_MAGIC
  39.     + sizeof(u_char)
  40. #endif
  41.     + sizeof(struct pfring_pkthdr)
  42.     + pfr->bucket_len /* flowSlot.bucket */ ;
  43. /*    
  44.         对于槽位空间的计算，有意思的是
  45. typedef struct flowSlot {
  46. #ifdef RING_MAGIC
  47.   u_char     magic;      /* It must alwasy be zero */
  48. #endif
  49.   u_char     slot_state; /* 0=empty, 1=full   */
  50.   u_char     bucket;     /* bucket[bucketLen] */
  51. } FlowSlot;
  52. 对照结构定义和上面的计算公式：
  53. 1、作者好像把magic和slog_state的顺序给搞反了，不过还好，它们都是u_char，对结果不影响
  54. 2、bucket，桶的大小，这个桶就是拿来装要捕获的数据包了，虽然它在结构中定义是一个成员，事实上，
  55. 它由两个部份组成，一个是包的首部信息，这个结构的定义同libpcap很接近。另一个才是包的空间。
  56. */

  58.         //总共的环形队列内存所需空间，包含一个队列控制信息FlowSlotInfo和若干个(由变量num_slots决定)槽位空间
  59.   tot_mem = sizeof(FlowSlotInfo) + num_slots * the_slot_len;
  60.   
  61.   //确保按整数页分配，mmap也要求这样
  62.   if(tot_mem % PAGE_SIZE)
  63.     tot_mem += PAGE_SIZE - (tot_mem % PAGE_SIZE);

  65.         //分配内存空间
  66.   pfr->ring_memory = rvmalloc(tot_mem);

  68.   if(pfr->ring_memory != NULL) {
  69.     printk("[PF_RING] successfully allocated %lu bytes at 0x%08lx\n",
  70.            (unsigned long)tot_mem, (unsigned long)pfr->ring_memory);
  71.   } else {
  72.     printk("[PF_RING] ERROR: not enough memory for ring\n");
  73.     return(-1);
  74.   }

  76.   // memset(pfr->ring_memory, 0, tot_mem); // rvmalloc does the memset already
  77.   //初始化各成员
  78.         //内存指定，因为分配的内存开始部份是sizeof(FlowSlotInfo)，所以可以做这样的强制转换，很容易互相取值
  79.   pfr->slots_info = (FlowSlotInfo *) pfr->ring_memory;
  80.   //跳过控制信息，指向槽位指针.事实上，它就是一个一维数组了，可以计算出合适的索引值，取到数组(RING)中的任意槽位值
  81.   pfr->ring_slots = (char *)(pfr->ring_memory + sizeof(FlowSlotInfo));

  83.   //版本信息
  84.   pfr->slots_info->version = RING_FLOWSLOT_VERSION;
  85.   //登记单个槽的大小
  86.   pfr->slots_info->slot_len = the_slot_len;
  87.   //登记bucket大小，从前面特别注释的bucket的分配看，bucket_len这个大小并不代表bucket成员的实际大小——它不包含struct pfring_pkthdr
  88.   pfr->slots_info->data_len = pfr->bucket_len;
  89.   //登记实际分配到的槽位数量，这里不用num_slots，难道是怕rvmalloc偷吃？
  90.   pfr->slots_info->tot_slots =
  91.     (tot_mem - sizeof(FlowSlotInfo)) / the_slot_len;
  92.   //登记实际分配的内存总数  
  93.   pfr->slots_info->tot_mem = tot_mem;
  94.   //采样速率？？
  95.   pfr->slots_info->sample_rate = 1;

  97.   printk("[PF_RING] allocated %d slots [slot_len=%d][tot_mem=%u]\n",
  98.          pfr->slots_info->tot_slots, pfr->slots_info->slot_len,
  99.          pfr->slots_info->tot_mem);

  101. #ifdef RING_MAGIC
  102.   {
  103.     int i;

  105.     for (i = 0; i < pfr->slots_info->tot_slots; i++) {
  106.       unsigned long idx = i * pfr->slots_info->slot_len;
  107.       FlowSlot *slot = (FlowSlot *) & pfr->ring_slots[idx];
  108.       slot->magic = RING_MAGIC_VALUE;
  109.       slot->slot_state = 0;
  110.     }
  111.   }
  112. #endif
  113.   //这些控制变量可以在环的入队操作中看到它们的作用
  114.   pfr->sample_rate = 1;        /* No sampling */
  115.   pfr->insert_page_id = 1, pfr->insert_slot_id = 0;
  116.   pfr->rules_default_accept_policy = 1, pfr->num_filtering_rules = 0;
  117.   ring_proc_add(ring_sk(sk), dev);

  119.   //记录与之相应的设备信息，例如，如果在eth0上打开了5 个PF_RING, bind
  120.   //被调用5次，分配了5个环形队列空间。eth0上随之分配5个elem，它们指向与
  121.   //之对应的ring，然后根据设备索引号民全部加入至了device_ring_list
  122.   //当有数据报文从指定接口进入时，可以很容易地在device_ring_list中找到相应的设备
  123.   //然后再遍历链表，再找到与之相应的ring
  124.   if(dev->ifindex < MAX_NUM_DEVICES) {
  125.     device_ring_list_element *elem;

  127.     /* printk("[PF_RING] Adding ring to device index %d\n", dev->ifindex); */

  129.     elem = kmalloc(sizeof(device_ring_list_element), GFP_ATOMIC);
  130.     if(elem != NULL) {
  131.       elem->the_ring = pfr;
  132.       INIT_LIST_HEAD(&elem->list);
  133.       write_lock(&ring_list_lock);
  134.       list_add(&elem->list, &device_ring_list[dev->ifindex]);
  135.       write_unlock(&ring_list_lock);
  136.       /* printk("[PF_RING] Added ring to device index %d\n", dev->ifindex); */
  137.     }
  138.   }

  140.   /*
  141.     IMPORTANT
  142.     Leave this statement here as last one. In fact when
  143.     the ring_netdev != NULL the socket is ready to be used.
  144.   */
  145.   pfr->ring_netdev = dev;

  147.   return(0);
  148. }
复制代码

这个函数中，最重要的三点：
1、整个空间的详细构成，作者画了一个简单的草图，清晰明了。
2、如果取得某个槽位。
3、device_ring_list链表的使用。

一些作者有详细注释的地方，我就不再重重了。

这一步进行完了后，就有一块内存了（系统将其看成一个数组），用来存储捕获的数据帧。接下来要做的事情。就是把它映射到用户态。

 4、mmap操作
用户态的接下来调用：
  1.                         ring->buffer = (char *)mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE,
  2.                                 MAP_SHARED, ring->fd, 0);
复制代码

进行内存映射。
同样地，内核调用相应的ring_mmap进行处理。
Ring选项结构通过ring_sk宏与sk 建立关联
  1. struct ring_opt *pfr = ring_sk(sk);
复制代码

pfr->ring_memory 即为分配的环形队列空间。所以，要mmap操作，实际上就是调用remap_pfn_range函数把pfr->ring_memory 映射到用户空间即可。这个函数的原型为：
  1. /**
  2. * remap_pfn_range - remap kernel memory to userspace
  3. * @vma: user vma to map to
  4. * @addr: target user address to start at
  5. * @pfn: physical address of kernel memory
  6. * @size: size of map area
  7. * @prot: page protection flags for this mapping
  8. *
  9. *  Note: this is only safe if the mm semaphore is held when called.
  10. */
  11. int remap_pfn_range(struct vm_area_struct *vma, unsigned long addr,
  12.                     unsigned long pfn, unsigned long size, pgprot_t prot)
  13. {
复制代码

关于remap_pfn_range函数的进一步说明，可以参考LDD3，上面有详细说明和现成的例子。

  1. static int ring_mmap(struct file *file,
  2.                      struct socket *sock, struct vm_area_struct *vma)
  3. {
  4.   struct sock *sk = sock->sk;
  5.   struct ring_opt *pfr = ring_sk(sk);                //取得pfr指针，也就是相应取得环形队列的内存空间地址指针
  6.   int rc;
  7.   unsigned long size = (unsigned long)(vma->vm_end - vma->vm_start);

  9.   if(size % PAGE_SIZE) {
  10. #if defined(RING_DEBUG)
  11.     printk("[PF_RING] ring_mmap() failed: "
  12.            "len is not multiple of PAGE_SIZE\n");
  13. #endif
  14.     return(-EINVAL);
  15.   }
  16. #if defined(RING_DEBUG)
  17.   printk("[PF_RING] ring_mmap() called, size: %ld bytes\n", size);
  18. #endif

  20.   if((pfr->dna_device == NULL) && (pfr->ring_memory == NULL)) {
  21. #if defined(RING_DEBUG)
  22.     printk("[PF_RING] ring_mmap() failed: "
  23.            "mapping area to an unbound socket\n");
  24. #endif
  25.     return -EINVAL;
  26.   }

  28.   //dns设备为空，即没有使用dns技术
  29.   if(pfr->dna_device == NULL) {
  30.     /* if userspace tries to mmap beyond end of our buffer, fail */
  31.     //映射空间超限
  32.     if(size > pfr->slots_info->tot_mem) {
  33. #if defined(RING_DEBUG)
  34.       printk("[PF_RING] ring_mmap() failed: "
  35.              "area too large [%ld > %d]\n",
  36.              size, pfr->slots_info->tot_mem);
  37. #endif
  38.       return(-EINVAL);
  39.     }
  40. #if defined(RING_DEBUG)
  41.     printk("[PF_RING] mmap [slot_len=%d]"
  42.            "[tot_slots=%d] for ring on device %s\n",
  43.            pfr->slots_info->slot_len, pfr->slots_info->tot_slots,
  44.            pfr->ring_netdev->name);
  45. #endif
  46.         //进行内存映射
  47.     if((rc =
  48.          do_memory_mmap(vma, size, pfr->ring_memory, VM_LOCKED,
  49.                         0)) < 0)
  50.       return(rc);
  51.   } else {
  52.     /* DNA Device */
  53.     if(pfr->dna_device == NULL)
  54.       return(-EAGAIN);

  56.     switch (pfr->mmap_count) {
  57.     case 0:
  58.       if((rc = do_memory_mmap(vma, size,
  59.                                (void *)pfr->dna_device->
  60.                                packet_memory, VM_LOCKED,
  61.                                1)) < 0)
  62.         return(rc);
  63.       break;

  65.     case 1:
  66.       if((rc = do_memory_mmap(vma, size,
  67.                                (void *)pfr->dna_device->
  68.                                descr_packet_memory, VM_LOCKED,
  69.                                1)) < 0)
  70.         return(rc);
  71.       break;

  73.     case 2:
  74.       if((rc = do_memory_mmap(vma, size,
  75.                                (void *)pfr->dna_device->
  76.                                phys_card_memory,
  77.                                (VM_RESERVED | VM_IO), 2)) < 0)
  78.         return(rc);
  79.       break;

  81.     default:
  82.       return(-EAGAIN);
  83.     }

  85.     pfr->mmap_count++;
  86.   }

  88. #if defined(RING_DEBUG)
  89.   printk("[PF_RING] ring_mmap succeeded\n");
  90. #endif

  92.   return 0;
  93. }
复制代码


实际上的内存映射工作，是由do_memory_mmap来完成的，这个函数实际上基本就是remap_pfn_range的包裹函数。
不过因为系统支持dna等技术，相应的mode参数有些变化，这里只分析了最基本的方法：mode == 0

  1. static int do_memory_mmap(struct vm_area_struct *vma,
  2.                           unsigned long size, char *ptr, u_int flags, int mode)
  3. {
  4.   unsigned long start;
  5.   unsigned long page;

  7.   /* we do not want to have this area swapped out, lock it */
  8.   vma->vm_flags |= flags;
  9.   start = vma->vm_start;

  11.   while (size > 0) {
  12.     int rc;

  14.     if(mode == 0) {
  15. #if(LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,11))
  16.           //根据地址，计算要映射的页帧
  17.       page = vmalloc_to_pfn(ptr);
  18.       //进行内存映射
  19.       rc = remap_pfn_range(vma, start, page, PAGE_SIZE,
  20.                            PAGE_SHARED);
  21. #else
  22.       page = vmalloc_to_page(ptr);
  23.       page = kvirt_to_pa(ptr);
  24.       rc = remap_page_range(vma, start, page, PAGE_SIZE,
  25.                             PAGE_SHARED);
  26. #endif
  27.     } else if(mode == 1) {
  28.       rc = remap_pfn_range(vma, start,
  29.                            __pa(ptr) >> PAGE_SHIFT,
  30.                            PAGE_SIZE, PAGE_SHARED);
  31.     } else {
  32.       rc = remap_pfn_range(vma, start,
  33.                            ((unsigned long)ptr) >> PAGE_SHIFT,
  34.                            PAGE_SIZE, PAGE_SHARED);
  35.     }

  37.     if(rc) {
  38. #if defined(RING_DEBUG)
  39.       printk("[PF_RING] remap_pfn_range() failed\n");
  40. #endif
  41.       return(-EAGAIN);
  42.     }

  44.     start += PAGE_SIZE;
  45.     ptr += PAGE_SIZE;
  46.     if(size > PAGE_SIZE) {
  47.       size -= PAGE_SIZE;
  48.     } else {
  49.       size = 0;
  50.     }
  51.   }

  53.   return(0);
  54. }
复制代码


嗯，跳过了太多的细节，不过其mmap最核心的东东已经呈现出来。
如果要共享内核与用户空间内存，这倒是个现成的可借鉴的例子。

5、数据包的入队操作

做到这一步，准备工作基本上就完成了。因为PF_RING在初始化中，注册了prot_hook。其func指针指向packet_rcv函数：
当数据报文进入Linux网络协议栈队列时，netif_receive_skb会遍历这些注册的Hook：
  1. int netif_receive_skb(struct sk_buff *skb)
  2. {
  3.         list_for_each_entry_rcu(ptype, &ptype_all, list) {
  4.                 if (ptype->dev == null_or_orig || ptype->dev == skb->dev ||
  5.                     ptype->dev == orig_dev) {
  6.                         if (pt_prev)
  7.                                 ret = deliver_skb(skb, pt_prev, orig_dev);
  8.                         pt_prev = ptype;
  9.                 }
  10.         }
  11. }
复制代码


相应的Hook函数得到调用：

  1. static inline int deliver_skb(struct sk_buff *skb,
  2.                               struct packet_type *pt_prev,
  3.                               struct net_device *orig_dev)
  4. {
  5.         atomic_inc(&skb->users);        //注意，这里引用计数器被增加了
  6.         return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
  7. }
复制代码


packet_rcv随之执行环形队列的入队操作：
  1. static int packet_rcv(struct sk_buff *skb, struct net_device *dev,
  2.                       struct packet_type *pt, struct net_device *orig_dev)
  3. {
  4.   int rc;

  6.   //忽略本地环回报文
  7.   if(skb->pkt_type != PACKET_LOOPBACK) {
  8.           //进一步转向，最后一个参数直接使用-1，从上下文来看，写为RING_ANY_CHANNEL(其实也是-1)似乎可读性更强，
  9.           //这里表示，如果从packet_rcv进入队列，由通道ID是“未指定的”，由skb_ring_handler来处理
  10.     rc = skb_ring_handler(skb,
  11.                           (skb->pkt_type == PACKET_OUTGOING) ? 0 : 1,
  12.                           1, -1 /* unknown channel */);

  14.   } else
  15.     rc = 0;

  17.   kfree_skb(skb);                                //所以，这里要做相应的减少
  18.   return(rc);
  19. }
复制代码



static int skb_ring_handler(struct sk_buff *skb,                                //要捕获的数据包
                            u_char recv_packet,                                                                //数据流方向，>0表示是进入(接收)方向
                            u_char real_skb /* 1=real skb, 0=faked skb */ ,
                            short channel_id)                                                                //通道ID
{
  struct sock *skElement;
  int rc = 0, is_ip_pkt;
  struct list_head *ptr;
  struct pfring_pkthdr hdr;
  int displ;
  struct sk_buff *skk = NULL;
  struct sk_buff *orig_skb = skb;

#ifdef PROFILING
  uint64_t rdt = _rdtsc(), rdt1, rdt2;
#endif

  //skb合法检查，包括数据流的方向
  if((!skb)                /* Invalid skb */
      ||((!enable_tx_capture) && (!recv_packet))) {
    /*
      An outgoing packet is about to be sent out
      but we decided not to handle transmitted
      packets.
    */
    return(0);
  }
#if defined(RING_DEBUG)
  if(1) {
    struct timeval tv;

    skb_get_timestamp(skb, &tv);
    printk
      ("[PF_RING] skb_ring_handler() [skb=%p][%u.%u][len=%d][dev=%s][csum=%u]\n",
       skb, (unsigned int)tv.tv_sec, (unsigned int)tv.tv_usec,
       skb->len,
       skb->dev->name == NULL ? "<NULL>" : skb->dev->name,
       skb->csum);
  }
#endif

        //如果通道ID未指定，根据进入的报文设备索引，设定之
#if(LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21))
  if(channel_id == RING_ANY_CHANNEL /* Unknown channel */ )
    channel_id = skb->iif;        /* Might have been set by the driver */
#endif

#if defined (RING_DEBUG)
  /* printk("[PF_RING] channel_id=%d\n", channel_id); */
#endif

#ifdef PROFILING
  rdt1 = _rdtsc();
#endif

  if(recv_packet) {
    /* Hack for identifying a packet received by the e1000 */
    if(real_skb)
      displ = SKB_DISPLACEMENT;
    else
      displ = 0;        /* Received by the e1000 wrapper */
  } else
    displ = 0;
        
  //解析数据报文，并判断是否为IP报文
  is_ip_pkt = parse_pkt(skb, displ, &hdr);

  //分片处理,是一个可选的功能项，事实上，对大多数包捕获工具而言，它们好像都不使用底层库来完成这一功能
  /* (de)Fragmentation < [email protected] > */
  if(enable_ip_defrag
      && real_skb && is_ip_pkt && recv_packet && (ring_table_size > 0)) {
    } else {
#if defined (RING_DEBUG)
        printk("[PF_RING] Do not seems to be a fragmented ip_pkt[iphdr=%p]\n",
               iphdr);
#endif
      }
    }
  }

  //按惯例，在报文的捕获首部信息中记录捕获的时间戳
  /* BD - API changed for time keeping */
#if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))
  if(skb->stamp.tv_sec == 0)
    do_gettimeofday(&skb->stamp);
  hdr.ts.tv_sec = skb->stamp.tv_sec, hdr.ts.tv_usec = skb->stamp.tv_usec;
#elif(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22))
  if(skb->tstamp.off_sec == 0)
    __net_timestamp(skb);
  hdr.ts.tv_sec = skb->tstamp.off_sec, hdr.ts.tv_usec =
    skb->tstamp.off_usec;
#else /* 2.6.22 and above */
  if(skb->tstamp.tv64 == 0)
    __net_timestamp(skb);
  hdr.ts = ktime_to_timeval(skb->tstamp);
#endif

  //除了时间，还有长度，熟悉libpcap的话，这些操作应该很眼熟
  hdr.len = hdr.caplen = skb->len + displ;

  /* Avoid the ring to be manipulated while playing with it */
  read_lock_bh(&ring_mgmt_lock);

  /* 前面在创建sk时，已经看过ring_insert的入队操作了，现在要检查它的成员
  * 它们的关系是，通过ring_table的成员，获取到element，它里面封装了sk，
  *通过ring_sk宏，就可以得到ring_opt指针
   */
  list_for_each(ptr, &ring_table) {
    struct ring_opt *pfr;
    struct ring_element *entry;

    entry = list_entry(ptr, struct ring_element, list);

    skElement = entry->sk;
    pfr = ring_sk(skElement);
        
        //看来要加入社团，条件还是满多的,pfr不能为空，未指定集群cluster_id，槽位不能为空，方向要正确，绑定的网络设备
        //得对上号
        //另一种可能就是对bonding的支持，如果设备是从属设备，则应校验其主设备
    if((pfr != NULL)
        && (pfr->cluster_id == 0 /* No cluster */ )
        && (pfr->ring_slots != NULL)
        && is_valid_skb_direction(pfr->direction, recv_packet)
        && ((pfr->ring_netdev == skb->dev)
            || ((skb->dev->flags & IFF_SLAVE)
                && (pfr->ring_netdev == skb->dev->master)))) {
      /* We've found the ring where the packet can be stored */
      /* 从新计算捕获帧长度，是因为可能因为巨型帧的出现——超过了桶能容纳的长度 */
      int old_caplen = hdr.caplen;        /* Keep old lenght */
      hdr.caplen = min(hdr.caplen, pfr->bucket_len);
      /* 入队操作 */
      add_skb_to_ring(skb, pfr, &hdr, is_ip_pkt, displ, channel_id);
      hdr.caplen = old_caplen;
      rc = 1;        /* Ring found: we've done our job */
    }
  }

  /* [2] Check socket clusters */
  list_for_each(ptr, &ring_cluster_list) {
    ring_cluster_element *cluster_ptr;
    struct ring_opt *pfr;

    cluster_ptr = list_entry(ptr, ring_cluster_element, list);

    if(cluster_ptr->cluster.num_cluster_elements > 0) {
      u_int skb_hash = hash_pkt_cluster(cluster_ptr, &hdr);

      skElement = cluster_ptr->cluster.sk[skb_hash];

      if(skElement != NULL) {
        pfr = ring_sk(skElement);

        if((pfr != NULL)
            && (pfr->ring_slots != NULL)
            && ((pfr->ring_netdev == skb->dev)
                || ((skb->dev->flags & IFF_SLAVE)
                    && (pfr->ring_netdev ==
                        skb->dev->master)))
            && is_valid_skb_direction(pfr->direction, recv_packet)
            ) {
          /* We've found the ring where the packet can be stored */
          add_skb_to_ring(skb, pfr, &hdr,
                          is_ip_pkt, displ,
                          channel_id);
          rc = 1;        /* Ring found: we've done our job */
        }
      }
    }
  }

  read_unlock_bh(&ring_mgmt_lock);

#ifdef PROFILING
  rdt1 = _rdtsc() - rdt1;
#endif

#ifdef PROFILING
  rdt2 = _rdtsc();
#endif

  /* Fragment handling */
  if(skk != NULL)
    kfree_skb(skk);

  if(rc == 1) {
    if(transparent_mode != driver2pf_ring_non_transparent) {
      rc = 0;
    } else {
      if(recv_packet && real_skb) {
#if defined(RING_DEBUG)
        printk("[PF_RING] kfree_skb()\n");
#endif

        kfree_skb(orig_skb);
      }
    }
  }
#ifdef PROFILING
  rdt2 = _rdtsc() - rdt2;
  rdt = _rdtsc() - rdt;

#if defined(RING_DEBUG)
  printk
    ("[PF_RING] # cycles: %d [lock costed %d %d%%][free costed %d %d%%]\n",
     (int)rdt, rdt - rdt1,
     (int)((float)((rdt - rdt1) * 100) / (float)rdt), rdt2,
     (int)((float)(rdt2 * 100) / (float)rdt));
#endif
#endif

  //printk("[PF_RING] Returned %d\n", rc);
  return(rc);                /*  0 = packet not handled */
}

上面跳过了对cluster(集群)的分析，PF_RING允许同时对多个接口捕获报文，而并不是一个。这就是集群。看一下它用户态的注释就一目了然了：
  1.                         /* Syntax
  2.                         ethX@1,5       channel 1 and 5
  3.                         ethX@1-5       channel 1,2...5
  4.                         ethX@1-3,5-7   channel 1,2,3,5,6,7
  5.                         */
复制代码

进一步的入队操作，是通过add_skb_to_ring来完成的：

  1. static int add_skb_to_ring(struct sk_buff *skb,
  2.                            struct ring_opt *pfr,
  3.                            struct pfring_pkthdr *hdr,
  4.                            int is_ip_pkt, int displ, short channel_id)
  5. {
  6.       //add_skb_to_ring函数比较复杂，因为它要处理过滤器方面的问题。
  7.       //关于PF_RING的过滤器，可以参考[url]http://luca.ntop.org/Blooms.pdf[/url]
  8.       //获取更多内容。这里不做详细讨论了。或者留到下回分解吧。
  9.       
  10.       //最终入队操作，是通过调用dd_pkt_to_ring来实现的。
  11.       add_pkt_to_ring(skb, pfr, hdr, displ, channel_id,
  12.                       offset, mem);        
  13. }
复制代码

  1. static void add_pkt_to_ring(struct sk_buff *skb,
  2.                             struct ring_opt *pfr,
  3.                             struct pfring_pkthdr *hdr,
  4.                             int displ, short channel_id,
  5.                             int offset, void *plugin_mem)
  6. {
  7.   char *ring_bucket;
  8.   int idx;
  9.   FlowSlot *theSlot;
  10.   int32_t the_bit = 1 << channel_id;

  12. #if defined(RING_DEBUG)
  13.   printk("[PF_RING] --> add_pkt_to_ring(len=%d) [pfr->channel_id=%d][channel_id=%d]\n",
  14.          hdr->len, pfr->channel_id, channel_id);
  15. #endif

  17.   //检查激活标志
  18.   if(!pfr->ring_active)
  19.     return;

  21.   if((pfr->channel_id != RING_ANY_CHANNEL)
  22.       && (channel_id != RING_ANY_CHANNEL)
  23.       && ((pfr->channel_id & the_bit) != the_bit))
  24.     return; /* Wrong channel */

  26.   //写锁
  27.   write_lock_bh(&pfr->ring_index_lock);
  28.   //获取前一次插入的位置索引
  29.   idx = pfr->slots_info->insert_idx;
  30.   //调用get_insert_slot获取当前要捕获数据报文的合适的槽位
  31.   //这里idx++后，指向了下一次插入的位置索引
  32.   idx++, theSlot = get_insert_slot(pfr);
  33.   //累计计数器
  34.   pfr->slots_info->tot_pkts++;

  36.   //没位子了，累计丢包计数器，返回之
  37.   if((theSlot == NULL) || (theSlot->slot_state != 0)) {
  38.     /* No room left */
  39.     pfr->slots_info->tot_lost++;
  40.     write_unlock_bh(&pfr->ring_index_lock);
  41.     return;
  42.   }

  44.   //获取当前槽位的桶
  45.   ring_bucket = &theSlot->bucket;

  47.   //支持插件？？在最开始处记录插件信息？？
  48.   if((plugin_mem != NULL) && (offset > 0))
  49.     memcpy(&ring_bucket[sizeof(struct pfring_pkthdr)], plugin_mem, offset);  

  51.   if(skb != NULL) {
  52.           //重新计算捕获帧长度
  53.     hdr->caplen = min(pfr->bucket_len - offset, hdr->caplen);

  55.     if(hdr->caplen > 0) {
  56. #if defined(RING_DEBUG)
  57.       printk("[PF_RING] --> [caplen=%d][len=%d][displ=%d][parsed_header_len=%d][bucket_len=%d][sizeof=%d]\n",
  58.          hdr->caplen, hdr->len, displ,
  59.              hdr->parsed_header_len, pfr->bucket_len,
  60.              sizeof(struct pfring_pkthdr));
  61. #endif
  62.       //拷贝捕获的数据报文，前面空了两个栏位：一个是pkthdr首部，一个是插件offset长度
  63.       //这里经过了一次数据拷贝，对于完美主义者，这并不是一个好的方法。但是PF_RING定位于一个
  64.       //通用的接口库，似乎只有这么做了。否则，追求“零拷贝”，为了避免这一次拷贝，只有逐个修改网卡驱动了。
  65.       skb_copy_bits(skb, -displ,
  66.                     &ring_bucket[sizeof(struct pfring_pkthdr) + offset], hdr->caplen);
  67.     } else {
  68.       if(hdr->parsed_header_len >= pfr->bucket_len) {
  69.         static u_char print_once = 0;

  71.         if(!print_once) {
  72.           printk("[PF_RING] WARNING: the bucket len is [%d] shorter than the plugin parsed header [%d]\n",
  73.              pfr->bucket_len, hdr->parsed_header_len);
  74.           print_once = 1;
  75.         }
  76.       }
  77.     }
  78.   }

  80.   //记录首部
  81.   memcpy(ring_bucket, hdr, sizeof(struct pfring_pkthdr)); /* Copy extended packet header */

  83.   //前面idx已经自加过了，判断是否队列已满，若满，归零，否则更新插入索引
  84.   if(idx == pfr->slots_info->tot_slots)
  85.     pfr->slots_info->insert_idx = 0;
  86.   else
  87.     pfr->slots_info->insert_idx = idx;

  89. #if defined(RING_DEBUG)
  90.   printk("[PF_RING] ==> insert_idx=%d\n", pfr->slots_info->insert_idx);
  91. #endif

  93.   //累计插入计数器
  94.   pfr->slots_info->tot_insert++;
  95.   //槽位就绪标记，用户空间可以来取了
  96.   theSlot->slot_state = 1;
  97.   write_unlock_bh(&pfr->ring_index_lock);

  99.   //有的时候会出现，用户空间取不到的情况，如队列为空。这样，用户空间调用poll等待数据。这里做相应的唤醒处理
  100.   /* wakeup in case of poll() */
  101.   if(waitqueue_active(&pfr->ring_slots_waitqueue))
  102.     wake_up_interruptible(&pfr->ring_slots_waitqueue);
  103. }
复制代码


槽位的计算:

  1. 在ring_bind函数中，分配空间后，使用ring_slots做为槽位指针。事实上，这里要计算槽位，就是通过索引号 * 槽位长度来得到：
  2. static inline FlowSlot *get_insert_slot(struct ring_opt *pfr)
  3. {
  4.   if(pfr->ring_slots != NULL) {
  5.     FlowSlot *slot =
  6.       (FlowSlot *) & (pfr->
  7.                       ring_slots[pfr->slots_info->insert_idx *
  8.                                  pfr->slots_info->slot_len]);
  9. #if defined(RING_DEBUG)
  10.     printk
  11.       ("[PF_RING] get_insert_slot(%d): returned slot [slot_state=%d]\n",
  12.        pfr->slots_info->insert_idx, slot->slot_state);
  13. #endif
  14.     return(slot);
  15.   } else {
  16. #if defined(RING_DEBUG)
  17.     printk("[PF_RING] get_insert_slot(%d): NULL slot\n",
  18.            pfr->slots_info->insert_idx);
  19. #endif
  20.     return(NULL);
  21.   }
  22. }
复制代码


整理中，未完，待续。。。。。。

你可能感兴趣的:(PF_RING实现分析)

  • 一刷Day7|454.四数相加II 15. 三数之和 18. 四数之和 Alisa-AY 哈希算法c语言
    文章目录454.四数相加II识别核心/易错难点/亮点算法设计思路代码实现代码实现分析15.三数之和（排序数组后左右双指针法，abc均去重）##识别核心/易错难点/亮点算法设计思路代码实现代码注释18.四数之和（在三数之和的基础上套了一层for循环numsk，剪枝&去重）识别核心/易错难点/亮点算法设计思路代码实现代码注释383.赎金信454.四数相加II识别本题有4个数组，较四数之和（一个数组），
  • 《实现 HTML 图片轮播效果》 小刘| html前端
    目录（一）HTML结构（二）CSS样式（三）JavaScript实现轮播逻辑一、轮播效果的重要性与应用场景在网页设计中，轮播效果是非常常见且重要的元素。它可以在有限的空间内展示多张图片或者广告，能够有效地吸引用户的注意力，提高信息展示的效率。常用于网站首页的焦点图展示、商品图片展示等场景。二、HTML轮播效果的实现分析以下是一个简单的HTML、CSS和JavaScript实现的图片轮播代码示例。（
  • Android图形架构实现分析总结 shenbin1430 Android系统图形androidbufferlayer浏览器算法
    Android图形架构分析总结总结其实现方案，主要包括了以下几个关键点：1、直接FrameBuffer的访问方式，并对FrameBuffer采用双缓存技术没有采用X-Server等方案，直接操作framebuffer，可以减少X-Server带来的通信开销。打开framebuffer,创建两个缓冲区，（一个是onscreenfrontbuffer，另一个backbuffer,可能位于offscre
  • Android CCodec Codec2 （九）组件实现分析 青山渺渺 AndroidMedia框架剖析androidCCodecAndroidCodec2音视频
    在上一篇文章中，我们详细梳理了HIDL层组件的创建过程。在这一篇文章中，我们将以C2SoftMpeg2Dec为例简单了解SWC2Component的实现架构。1、C2SoftMpeg2DecFactoryC2ComponentStore通过调用组件实现的C2ComponentFactory完成组件的创建，C2SoftMpeg2Dec实现的factory名为C2SoftMpeg2DecFactory
  • SpringBoot(13)过滤器+拦截器+监听器 邱秋Elena springboot
    文章目录一、过滤器1.过滤器介绍2.Filter生命周期4、注解方式实现过滤器（@WebFilter）@WebFilter@Order(1)@ServletComponentScan启动类代码Filter代码5、直接注入到spring中Filter代码Filter配置类代码二、拦截器1.拦截器介绍2.拦截器生命周期3.自定义拦截器案例——性能监控3.1实现分析：3.2问题：3.3解决方案3.4拦截
  • JAVA项目一 家庭收支记账软件 D_D_zy javajava基础java
    JAVA学习项目一家庭收支记账软件学习项目之一家庭收支记账软件项目任务项目技术实现分析流程分析解决思路Utility工具类主程序实现循环语句分支语句代码说明实验总结学习项目之一家庭收支记账软件项目任务模拟实现基于文本界面的家庭记账收支软件。该软件能够记录个人收入或支出，并能够打印出收支明细概况。项目采用分级菜单方式，主菜单如下：项目技术局部变量和基本数据类型。循环语句和分支语句。方法调用和返回值的
  • JSP+JSTL+EL表达式，实现web页面的页面跳转功能（上一页下一页首页末页页面跳转） Aussise javasql开发语言tomcat
    一、分页显示无处不在意义：实际中不会将所有数据一起显示出来，所以需要考虑数据的分页显示二、前期准备（1）jar包（2）导入c标签库三、具体实现分析实现：首页上一页通过超链接，跳转到BookServlet，并且传递pageNo来实现1}">首页上一页首页下一页实现：末页下一页，可以同上方法，也可使用jQuery实现：下一页末页共${requestScope.page.pageTotal}页$(fun
  • Boost::asio io_service 实现分析 Turbock #Boost#C/C++
    io_service的作用io_servie实现了一个任务队列，这里的任务就是void(void)的函数。Io_servie最常用的两个接口是post和run，post向任务队列中投递任务，run是执行队列中的任务，直到全部执行完毕，并且run可以被N个线程调用。Io_service是完全线程安全的队列。Io_servie的接口提供的接口有run、run_one、poll、poll_one、sto
  • MVCC原理探究及MySQL源码实现分析 老叶茶馆_
    来源｜沃趣科技（ID：woqutech）作者｜董红禹目录预览数据库多版本读场景MVCC实现原理1、通过DB_ROLL_PT回溯查找数据历史版本2、通过readview判断行记录是否可见MVCC解决了什么问题MySQL代码分析1、InnoDB隐藏字段源码分析2、InnoDB判断事务可见性源码分析数据库多版本读场景session1session2selectafromtest;returna=10st
  • ruoyi若依框架分页功能实现分析 Gunalaer springboot前端springboot后端javavue
    系列文章ruoyi若依框架学习笔记-01ruoyi若依框架分页功能实现分析ruoyi若依框架SpringSecurity实现分析文章目录系列文章概要前端分析后端分析概要今天来分析一下若依前后端分离版本的分页功能的实现，以系统用户页面为例，从前后端一一分析。前端分析我把相关的js代码拿出来放到一起，total即分页数据的总数，和total绑定，page即页号，limit即页面数据大小限制，都和que
  • ruoyi若依框架学习笔记-01 Gunalaer springboot前端学习笔记springbootvue
    系列文章目录ruoyi若依框架学习笔记-01ruoyi若依框架分页实现分析ruoyi若依框架SpringSecurity实现分析文章目录系列文章目录项目结构分析项目环境要求启动项目启动后端启动前端业务模块分析验证码模块前端分析后端分析登录模块前端分析后端分析项目结构分析项目环境要求JDK>=1.8(推荐1.8版本)Mysql>=5.7.0(推荐5.7版本)Redis>=3.0Maven>=3.0N
  • ruoyi若依框架SpringSecurity实现分析 Gunalaer springbootspringsecurityjavaspringboot后端
    系列文章ruoyi若依框架学习笔记-01ruoyi若依框架分页实现分析ruoyi若依框架SpringSecurity实现分析文章目录系列文章前言具体分析一、项目中的SpringSecurity版本二、登录认证流程分析三、权限鉴定四、退出登录五、SpringSecurity配置类总结前言在ruoyi-vue若依框架中使用到了SpringSecurity作为认证授权的技术栈。今天，来分析一下若依中是如
  • 锁（一）java中的锁相关 w_t_y_y 多线程编程安全javajvm
    《Java并发编程的艺术》-Java并发包中的读写锁及其实现分析|并发编程网–ifeve.com一、java.util.concurrent.Lock接口1、锁的简单介绍锁可以控制多个线程访问共享资源的方式，可以防止多个线程同时访问共享资源（但是有些锁可以允许多个线程并发地访问共享资源，如读写锁）。2、锁的实现方式在不同JDK版本，实现锁的方式不同（1）javaSE5之前:通过synchroniz
  • QEMU&KVM 虚拟机实例demo以及RISCV上KVM的实现分析 papaofdoudou KVM虚拟化内存管理linuxKVMQEMU
    KVM（KernelVirtualMachine)是基于Linux内核的开源的虚拟化解决方案，KVM从linux-2.6.20版本开始被合入kernel主分支维护，成为linux的重要模块之一。KVM本身能够提供CPU虚拟化和内存虚拟化等部分功能，而其它设备的虚拟化和虚拟机的管理工作，则需要依靠QEMU完成，在KVM虚拟化环境中，一个虚拟机就是一个传统的Linux进程，运行在Qemu-KVM进程的
  • AQS的思想 无善无恶
    深度解析Java8：JDK1.8AbstractQueuedSynchronizer的实现分析（上）这四种方法对应两种模式，留给子类去实现：独占锁模式：tryAcquiretryRelease共享锁模式：tryAcquireSharedtryReleaseShared非公平锁的lock方法的处理方式是:在lock的时候先直接cas修改一次state变量（尝试获取锁），成功就返回，不成功再排队，从而
  • 常见的限流场景、限流算法、限流实现分析 码拉松 经验分享限流限流算法
    前言限流是分布式系统中不可缺少的应对突发大流量的重要手段之一，能够让系统具有更好的弹性能力。限流场景限流应用的场景也非常的多，许多灵感从现实生活中也都能找到，比如节假日一些游玩景点的限流，购物品对每人的购买数量的限制，吃饭排队等餐的限制等等，你会发现生活中的限流无处无在。回到我们的系统服务中，当然也可以完成这样的事情，不过除了这些正常的访问请求之外，在互联网中你难免要遭遇一些恶意的攻击，通过限流的
  • 队列的实现 垂柳斜下茉莉雨 数据结构数据结构
    学习就像一段长跑，比的不是谁跑得快，而是谁更能坚持！！1队列的概念及结构队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(FirstInFirstOut)入队列：进行插入操作的一端称为队尾。出队列：进行删除操作的一端称为队头。和栈不同的是，队列的出队顺序是唯一的！2队列的实现分析有两种实现队列的方式：数组和链表。链表可以用单链表也可以用双链表。使用
  • Linux：无锁化编程 __sync_fetch_and_add原理及其实现分析 技术探索者 #Clinux知识__sync_fetch
    背景linux支持的哪些操作是具有原子特性的？知道这些东西是理解和设计无锁化编程算法的基础。我们知道，count++操作不是原子的。一个自加操作，本质是分成三步的：从缓存取到寄存器在寄存器加1存入缓存。由于时序的因素，多个线程操作同一个全局变量，会出现问题。这也是并发编程的难点。在目前多核条件下，这种困境会越来越彰显出来。最简单的处理办法就是加锁保护，看下面的代码：pthread_mutex_tc
  • 并行化K-means聚类算法的实现与分析 OverlordDuke 聚类算法算法kmeans聚类并行聚类算法
    并行化K-means聚类算法并行化K-means聚类算法的实现与分析项目背景与意义算法原理与串行实现分析并行化策略与关键细节实验结果与讨论未来改进方向结语并行化K-means聚类算法的实现与分析在大数据时代，对数据进行高效的聚类是数据分析与挖掘的重要工具之一。本文将介绍并讨论使用OpenMP在C++中实现的并行化K-means聚类算法。我们将深入探讨算法的原理、并行化策略以及实验结果，以期为相关领
  • 如何使用线上页面调试本地接口？(Nginx反向代理到本地, 并使用原的cookie) 瑶山 运维Javanginx前端服务器代理本地
    目录场景实现分析场景前后端分离项目，我本意是使用测试环境的页面访问我本地的服务，首先改了本地的hosts文件，hosts地址：C:\Windows\System32\drivers\etc\hosts#映射地址指向本地127.0.0.1open.test.com但是授权登录是另外一个服务，需要走测试环境的接口，只用IP的话就不太满足，就想着使用nginx代理下#请求测试环境授权登录open.tes
  • 四种“栈溢出检测方法”实现分析（2种纯软件、一种纯硬件、一种软硬件结合） 正在起飞的蜗牛 嵌入式开发中的总结栈空间C语言
    1、两种纯软件的栈溢出检测方法参考博客：《freeRTOS的栈溢出检测机制》；2、纯硬件：使用栈限制寄存器2.1、工作逻辑分析前提条件：使用满减栈硬件上提供栈限制寄存器（用SP_limit表示），可以通过设置栈限制寄存器来告诉硬件，可用栈空间的最低地址，也就是知道了栈空间能使用的最后地址在每次申请栈空间，也就是修改SP寄存器的值时，判断SP是否小于SP_limit，如果小于则说明发生栈溢出，产生异
  • Redis经典五大类型源码及底层实现 Fiercezm redis数据库缓存面试
    Redis经典五大类型源码及底层实现分析1、一些题目redis的zset底层实现？redis的跳表和压缩列表说一下，解决了哪些问题，时间复杂度和空间复杂度如何？redis的zset使用的是什么数据结构？Redis数据类型的底层数据结构SDS动态字符串双向链表压缩列表ziplist哈希表hashtable跳表skiplist整数集合intset快速列表quicklist紧凑列表listpack源码位
  • Linux Mii management/mdio子系统分析之四 mdio总线及phy驱动模型及其开发流程 Amonter Linux以太网linux运维服务器
    （转载）原文链接：https://blog.csdn.net/u014044624/article/details/123303208前三篇文章完成了mdio子系统概述、mdio子系统驱动模型概述、mii_bus子模块方法及驱动实现分析，本篇文章我们主要进行mdio总线驱动实现分析、phy驱动实现分析等部分，涉及的内容如下：一、mdio总线实现及相应方法分析二、phy驱动实现相应方法的分析三、ph
  • spring基于注解的事务管理器自动配置实现分析 用心一 springjava后端
    上一篇文章分析了AnnotationConfigApplicationContext这个上下文的初始化过程。当应用程序开启了事务管理的时候在ApplicationContext的refresh方法中调用invokeBeanFactoryPostProcessors解析配置类，最终会读取到配置类中事务配置。读取事务配置类的入口在ConfigurationClassParser的以下方法private
  • ARMv8-AArch64 的异常处理模型详解之异常等级、执行状态以及安全状态 SOC罗三炮 ARM安全
    ARMv8-AArch64的异常处理模型详解一，特权和异常等级1.1异常等级Exceptionlevels二，特权的类型2.1内存特权2.2访问寄存器的特权三，执行状态和安全状态3.1执行状态Executionstates3.2执行状态切换3.3安全状态Securitystates3.4改变安全状态四，异常等级和执行状态的具体实现分析一，特权和异常等级在了解AArch64异常等级模型之前，有必要先
  • 一条简单SQL的加锁实现分析 lbcBoy
    一篇很好的文章，mark！写在前面：隔离级别：IsolationLevel，也是RDBMS的一个关键特性。相信对数据库有所了解的朋友，对于4种隔离级别：ReadUncommited，ReadCommitted，RepeatableRead，Serializable，都有了深入的认识。本文不打算讨论数据库理论中，是如何定义这4种隔离级别的含义的，而是跟大家介绍一下MySQL/InnoDB是如何定义这
  • 【JavaScript】 ---- 数组元素的添加和删除 Rattenking Rattenking的前端笔记javascript开发语言ecmascript
    1.实现预览2.实现分析实现就是对数组元素的位置改变；使用数组的splice方法实现；使用es6解构赋值。3.实现操作函数//数组操作functionhandleList(type,list,idx,value){return{'delete':()=>{//删除list.splice(idx,1)return[...list]},'add':()=>{//新增list.splice(idx,0,
  • 策略模式+责任链模式配合Nacos实现参数校验链 原来是好奇心 java
    1、业务场景在SpringBoot项目中，针对接收的参数信息，根据需求要进行以下校验：校验客户的apikey是否合法；校验请求的ip地址是否是白名单；校验短信的签名；校验短信的模板；校验手机号的格式合法性；校验客户剩余的金额是否充足。2、实现分析对于接口需要校验的参数和信息，为了保证校验的方式做到动态可插拔，而且有利于后期的扩展，参考了Mybatis二级缓存的源码，采用策略模式+责任链模式的套路。
  • 推荐系统中协同过滤算法实现分析 weixin_33853794 人工智能python数据库
    2019独角兽企业重金招聘Python工程师标准>>>原创博客，欢迎转载，转载请注明：http://my.oschina.net/BreathL/blog/62519最近研究Mahout比较多，特别是里面协同过滤算法；于是把协同过滤算法的这个实现思路与数据流程，总结了一下，以便以后对系统做优化时，有个清晰的思路，这样才能知道该如何优化且优化后数据亦能正确。推荐中的协同过滤算法简单说明下：首先，通过
  • Android Audio System深入探究之Audio HAL(基于Android9) Calvin880828 Android源码剖析android系统分析
    AudioHal1.重要接口文件分析2HAL初始化3openOutput流程分析3.1Hal层设备创建3.2AudioHwDevice分析3.3openOutputStream分析3.4AF及SystemHAL相关类UML4AudioHal实现分析4.1AudioHIDL接口4.2RK平台audiohal实现4.3AudioHardware相关类关系图1.重要接口文件分析Hal层分析主要涉及的接口
  • 面向对象面向过程 3213213333332132 java
    面向对象：把要完成的一件事，通过对象间的协作实现。 面向过程：把要完成的一件事，通过循序依次调用各个模块实现。 我把大象装进冰箱这件事为例，用面向对象和面向过程实现，都是用java代码完成。 1、面向对象 package bigDemo.ObjectOriented; /** * 大象类 * * @Description * @author FuJian
  • Java Hotspot: Remove the Permanent Generation bookjovi HotSpot
      openjdk上关于hotspot将移除永久带的描述非常详细，http://openjdk.java.net/jeps/122   JEP 122: Remove the Permanent Generation Author Jon Masamitsu Organization Oracle Created 2010/8/15 Updated 2011/
  • 正则表达式向前查找向后查找,环绕或零宽断言 dcj3sjt126com 正则表达式
    向前查找和向后查找 1. 向前查找：根据要匹配的字符序列后面存在一个特定的字符序列(肯定式向前查找)或不存在一个特定的序列(否定式向前查找)来决定是否匹配。.NET将向前查找称之为零宽度向前查找断言。     对于向前查找，出现在指定项之后的字符序列不会被正则表达式引擎返回。 2. 向后查找：一个要匹配的字符序列前面有或者没有指定的
  • BaseDao 171815164 seda
    import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.PreparedStatement; import java.sql.ResultSet; public class BaseDao { public Conn
  • Ant标签详解--Java命令 g21121 Java命令
            这一篇主要介绍与java相关标签的使用         终于开始重头戏了，Java部分是我们关注的重点也是项目中用处最多的部分。           1
  • [简单]代码片段_电梯数字排列 53873039oycg 代码
           今天看电梯数字排列是9 18 26这样呈倒N排列的,写了个类似的打印例子，如下:       import java.util.Arrays; public class 电梯数字排列_S3_Test { public static void main(S
  • Hessian原理 云端月影 hessian原理
    Hessian 原理分析 一．      远程通讯协议的基本原理 网络通信需要做的就是将流从一台计算机传输到另外一台计算机，基于传输协议和网络 IO 来实现，其中传输协议比较出名的有 http 、 tcp 、 udp 等等， http 、 tcp 、 udp 都是在基于 Socket 概念上为某类应用场景而扩展出的传输协
  • 区分Activity的四种加载模式----以及Intent的setFlags aijuans android
      在多Activity开发中，有可能是自己应用之间的Activity跳转，或者夹带其他应用的可复用Activity。可能会希望跳转到原来某个Activity实例，而不是产生大量重复的Activity。 这需要为Activity配置特定的加载模式，而不是使用默认的加载模式。 加载模式分类及在哪里配置 Activity有四种加载模式： standard singleTop
  • hibernate几个核心API及其查询分析 antonyup_2006 html.netHibernatexml配置管理
    (一)  org.hibernate.cfg.Configuration类         读取配置文件并创建唯一的SessionFactory对象.(一般,程序初始化hibernate时创建.)         Configuration co
  • PL/SQL的流程控制 百合不是茶 oraclePL/SQL编程循环控制
    PL/SQL也是一门高级语言,所以流程控制是必须要有的,oracle数据库的pl/sql比sqlserver数据库要难,很多pl/sql中有的sqlserver里面没有   流程控制; 分支语句 if 条件 then 结果 else 结果 end if ; 条件语句 case when 条件 then 结果; 循环语句 loop
  • 强大的Mockito测试框架 bijian1013 mockito单元测试
    一.自动生成Mock类        在需要Mock的属性上标记@Mock注解，然后@RunWith中配置Mockito的TestRunner或者在setUp()方法中显示调用MockitoAnnotations.initMocks(this);生成Mock类即可。二.自动注入Mock类到被测试类  &nbs
  • 精通Oracle10编程SQL(11)开发子程序 bijian1013 oracle数据库plsql
    /* *开发子程序 */ --子程序目是指被命名的PL/SQL块，这种块可以带有参数，可以在不同应用程序中多次调用 --PL/SQL有两种类型的子程序：过程和函数 --开发过程 --建立过程：不带任何参数 CREATE OR REPLACE PROCEDURE out_time IS BEGIN DBMS_OUTPUT.put_line(systimestamp); E
  • 【EhCache一】EhCache版Hello World bit1129 Hello world
    本篇是EhCache系列的第一篇，总体介绍使用EhCache缓存进行CRUD的API的基本使用，更细节的内容包括EhCache源代码和设计、实现原理在接下来的文章中进行介绍   环境准备 1.新建Maven项目   2.添加EhCache的Maven依赖 <dependency> <groupId>ne
  • 学习EJB3基础知识笔记 白糖_ beanHibernatejbosswebserviceejb
    最近项目进入系统测试阶段，全赖袁大虾领导有力，保持一周零bug记录，这也让自己腾出不少时间补充知识。花了两天时间把“传智播客EJB3.0”看完了，EJB基本的知识也有些了解，在这记录下EJB的部分知识，以供自己以后复习使用。   EJB是sun的服务器端组件模型，最大的用处是部署分布式应用程序。EJB (Enterprise JavaBean)是J2EE的一部分，定义了一个用于开发基
  • angular.bootstrap boyitech AngularJSAngularJS APIangular中文api
    angular.bootstrap 描述：     手动初始化angular。     这个函数会自动检测创建的module有没有被加载多次，如果有则会在浏览器的控制台打出警告日志，并且不会再次加载。这样可以避免在程序运行过程中许多奇怪的问题发生。   使用方法：     angular .
  • java-谷歌面试题-给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数 bylijinnan java
    public class SearchInShiftedArray { /** * 题目：给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数。 * 请在这个特殊数组中找出给定的整数。 * 解答： * 其实就是“旋转数组”。旋转数组的最小元素见http://bylijinnan.iteye.com/bl
  • 天使还是魔鬼？都是我们制造 ducklsl 生活教育情感
    ----------------------------剧透请原谅，有兴趣的朋友可以自己看看电影，互相讨论哦！！！     从厦门回来的动车上，无意中瞟到了书中推荐的几部关于儿童的电影。当然，这几部电影可能会另大家失望，并不是类似小鬼当家的电影，而是关于“坏小孩”的电影！     自己挑了两部先看了看，但是发现看完之后，心里久久不能平
  • [机器智能与生物]研究生物智能的问题 comsci 生物
          我想,人的神经网络和苍蝇的神经网络,并没有本质的区别...就是大规模拓扑系统和中小规模拓扑分析的区别....       但是,如果去研究活体人类的神经网络和脑系统,可能会受到一些法律和道德方面的限制,而且研究结果也不一定可靠,那么希望从事生物神经网络研究的朋友,不如把
  • 获取Android Device的信息 dai_lm android
    String phoneInfo = "PRODUCT: " + android.os.Build.PRODUCT; phoneInfo += ", CPU_ABI: " + android.os.Build.CPU_ABI; phoneInfo += ", TAGS: " + android.os.Build.TAGS; ph
  • 最佳字符串匹配算法（Damerau-Levenshtein距离算法）的Java实现 datamachine java算法字符串匹配
    原文：http://www.javacodegeeks.com/2013/11/java-implementation-of-optimal-string-alignment.html------------------------------------------------------------------------------------------------------------
  • 小学5年级英语单词背诵第一课 dcj3sjt126com englishword
    long 长的 show 给...看，出示 mouth 口，嘴 write 写   use 用，使用 take 拿，带来 hand 手 clever 聪明的   often 经常 wash 洗 slow 慢的 house 房子   water 水 clean 清洁的 supper 晚餐 out 在外   face 脸，
  • macvim的使用实战 dcj3sjt126com macvim
    macvim用的是mac里面的vim, 只不过是一个GUI的APP, 相当于一个壳   1. 下载macvim https://code.google.com/p/macvim/   2. 了解macvim :h               vim的使用帮助信息 :h macvim  
  • java二分法查找 蕃薯耀 java二分法查找二分法java二分法
    java二分法查找 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月23日 11:40:03 星期二 http:/
  • Spring Cache注解+Memcached hanqunfeng springmemcached
    Spring3.1 Cache注解  依赖jar包： <!-- simple-spring-memcached --> <dependency> <groupId>com.google.code.simple-spring-memcached</groupId> <artifactId>simple-s
  • apache commons io包快速入门 jackyrong apache commons
    原文参考 http://www.javacodegeeks.com/2014/10/apache-commons-io-tutorial.html   Apache Commons IO 包绝对是好东西，地址在http://commons.apache.org/proper/commons-io/，下面用例子分别介绍：   1）  工具类   2
  • 如何学习编程 lampcy java编程C++c
    首先,我想说一下学习思想.学编程其实跟网络游戏有着类似的效果.开始的时候,你会对那些代码,函数等产生很大的兴趣,尤其是刚接触编程的人,刚学习第一种语言的人.可是,当你一步步深入的时候,你会发现你没有了以前那种斗志.就好象你在玩韩国泡菜网游似的,玩到一定程度,每天就是练级练级,完全是一个想冲到高级别的意志力在支持着你.而学编程就更难了,学了两个月后,总是觉得你好象全都学会了,却又什么都做不了,又没有
  • 架构师之spring-----spring3.0新特性的bean加载控制@DependsOn和@Lazy nannan408 Spring3
    1.前言。    如题。 2.描述。    @DependsOn用于强制初始化其他Bean。可以修饰Bean类或方法，使用该Annotation时可以指定一个字符串数组作为参数，每个数组元素对应于一个强制初始化的Bean。 @DependsOn({"steelAxe","abc"}) @Comp
  • Spring4+quartz2的配置和代码方式调度 Everyday都不同 代码配置spring4quartz2.x定时任务
    前言：这些天简直被quartz虐哭。。因为quartz 2.x版本相比quartz1.x版本的API改动太多，所以，只好自己去查阅底层API……   quartz定时任务必须搞清楚几个概念： JobDetail——处理类 Trigger——触发器，指定触发时间，必须要有JobDetail属性，即触发对象 Scheduler——调度器，组织处理类和触发器，配置方式一般只需指定触发
  • Hibernate入门 tntxia Hibernate
      前言   使用面向对象的语言和关系型的数据库，开发起来很繁琐，费时。由于现在流行的数据库都不面向对象。Hibernate 是一个Java的ORM（Object/Relational Mapping）解决方案。   Hibernte不仅关心把Java对象对应到数据库的表中，而且提供了请求和检索的方法。简化了手工进行JDBC操作的流程。   如
  • Math类 xiaoxing598 Math
    一、Java中的数字（Math）类是final类，不可继承。 1、常数 PI：double圆周率 E：double自然对数 2、截取（注意方法的返回类型） double ceil(double d) 返回不小于d的最小整数 double floor(double d) 返回不大于d的整最大数 int round(float f) 返回四舍五入后的整数 long round
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他