projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
enable ramdisk
[openwrt.git] / target / linux / generic-2.6 / patches / 104-pf_ring.patch
1 diff --unified --recursive --new-file linux-2.6.15-rc6/include/linux/ring.h linux-2.6.15-rc6-1-686-smp-ring3/include/linux/ring.h
2 --- linux-2.6.15-rc6/include/linux/ring.h 1970-01-01 01:00:00.000000000 +0100
3 +++ linux-2.6.15-rc6-1-686-smp-ring3/include/linux/ring.h 2005-12-24 00:24:01.000000000 +0100
4 @@ -0,0 +1,107 @@
5 +/*
6 + * Definitions for packet ring
7 + *
8 + * 2004 - Luca Deri <deri@ntop.org>
9 + */
10 +#ifndef __RING_H
11 +#define __RING_H
12 +
13 +
14 +#define INCLUDE_MAC_INFO
15 +
16 +#ifdef INCLUDE_MAC_INFO
17 +#define SKB_DISPLACEMENT 14 /* Include MAC address information */
18 +#else
19 +#define SKB_DISPLACEMENT 0 /* Do NOT include MAC address information */
20 +#endif
21 +
22 +#define RING_MAGIC
23 +#define RING_MAGIC_VALUE 0x88
24 +#define RING_FLOWSLOT_VERSION 6
25 +#define RING_VERSION "3.1"
26 +
27 +#define SO_ADD_TO_CLUSTER 99
28 +#define SO_REMOVE_FROM_CLUSTER 100
29 +#define SO_SET_REFLECTOR 101
30 +
31 +/* *********************************** */
32 +
33 +#ifndef HAVE_PCAP
34 +struct pcap_pkthdr {
35 + struct timeval ts; /* time stamp */
36 + u_int32_t caplen; /* length of portion present */
37 + u_int32_t len; /* length this packet (off wire) */
38 +};
39 +#endif
40 +
41 +/* *********************************** */
42 +
43 +enum cluster_type {
44 + cluster_per_flow = 0,
45 + cluster_round_robin
46 +};
47 +
48 +/* *********************************** */
49 +
50 +#define RING_MIN_SLOT_SIZE (60+sizeof(struct pcap_pkthdr))
51 +#define RING_MAX_SLOT_SIZE (1514+sizeof(struct pcap_pkthdr))
52 +
53 +/* *********************************** */
54 +
55 +typedef struct flowSlotInfo {
56 + u_int16_t version, sample_rate;
57 + u_int32_t tot_slots, slot_len, data_len, tot_mem;
58 +
59 + u_int64_t tot_pkts, tot_lost;
60 + u_int64_t tot_insert, tot_read;
61 + u_int32_t insert_idx, remove_idx;
62 +} FlowSlotInfo;
63 +
64 +/* *********************************** */
65 +
66 +typedef struct flowSlot {
67 +#ifdef RING_MAGIC
68 + u_char magic; /* It must alwasy be zero */
69 +#endif
70 + u_char slot_state; /* 0=empty, 1=full */
71 + u_char bucket; /* bucket[bucketLen] */
72 +} FlowSlot;
73 +
74 +/* *********************************** */
75 +
76 +#ifdef __KERNEL__
77 +
78 +FlowSlotInfo* getRingPtr(void);
79 +int allocateRing(char *deviceName, u_int numSlots,
80 + u_int bucketLen, u_int sampleRate);
81 +unsigned int pollRing(struct file *fp, struct poll_table_struct * wait);
82 +void deallocateRing(void);
83 +
84 +/* ************************* */
85 +
86 +typedef int (*handle_ring_skb)(struct sk_buff *skb,
87 + u_char recv_packet, u_char real_skb);
88 +extern handle_ring_skb get_skb_ring_handler(void);
89 +extern void set_skb_ring_handler(handle_ring_skb the_handler);
90 +extern void do_skb_ring_handler(struct sk_buff *skb,
91 + u_char recv_packet, u_char real_skb);
92 +
93 +typedef int (*handle_ring_buffer)(struct net_device *dev,
94 + char *data, int len);
95 +extern handle_ring_buffer get_buffer_ring_handler(void);
96 +extern void set_buffer_ring_handler(handle_ring_buffer the_handler);
97 +extern int do_buffer_ring_handler(struct net_device *dev,
98 + char *data, int len);
99 +#endif /* __KERNEL__ */
100 +
101 +/* *********************************** */
102 +
103 +#define PF_RING 27 /* Packet Ring */
104 +#define SOCK_RING PF_RING
105 +
106 +/* ioctl() */
107 +#define SIORINGPOLL 0x8888
108 +
109 +/* *********************************** */
110 +
111 +#endif /* __RING_H */
112 diff --unified --recursive --new-file linux-2.6.15-rc6/net/core/dev.c linux-2.6.15-rc6-1-686-smp-ring3/net/core/dev.c
113 --- linux-2.6.15-rc6/net/core/dev.c 2005-12-19 01:36:54.000000000 +0100
114 +++ linux-2.6.15-rc6-1-686-smp-ring3/net/core/dev.c 2005-12-24 00:24:02.000000000 +0100
115 @@ -115,6 +115,56 @@
116 #endif /* CONFIG_NET_RADIO */
117 #include <asm/current.h>
118
119 +#if defined (CONFIG_RING) || defined(CONFIG_RING_MODULE)
120 +
121 +/* #define RING_DEBUG */
122 +
123 +#include <linux/ring.h>
124 +#include <linux/version.h>
125 +
126 +static handle_ring_skb ring_handler = NULL;
127 +
128 +handle_ring_skb get_skb_ring_handler() { return(ring_handler); }
129 +
130 +void set_skb_ring_handler(handle_ring_skb the_handler) {
131 + ring_handler = the_handler;
132 +}
133 +
134 +void do_skb_ring_handler(struct sk_buff *skb,
135 + u_char recv_packet, u_char real_skb) {
136 + if(ring_handler)
137 + ring_handler(skb, recv_packet, real_skb);
138 +}
139 +
140 +/* ******************* */
141 +
142 +static handle_ring_buffer buffer_ring_handler = NULL;
143 +
144 +handle_ring_buffer get_buffer_ring_handler() { return(buffer_ring_handler); }
145 +
146 +void set_buffer_ring_handler(handle_ring_buffer the_handler) {
147 + buffer_ring_handler = the_handler;
148 +}
149 +
150 +int do_buffer_ring_handler(struct net_device *dev, char *data, int len) {
151 + if(buffer_ring_handler) {
152 + buffer_ring_handler(dev, data, len);
153 + return(1);
154 + } else
155 + return(0);
156 +}
157 +
158 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
159 +EXPORT_SYMBOL(get_skb_ring_handler);
160 +EXPORT_SYMBOL(set_skb_ring_handler);
161 +EXPORT_SYMBOL(do_skb_ring_handler);
162 +
163 +EXPORT_SYMBOL(get_buffer_ring_handler);
164 +EXPORT_SYMBOL(set_buffer_ring_handler);
165 +EXPORT_SYMBOL(do_buffer_ring_handler);
166 +#endif
167 +
168 +#endif
169 /*
170 * The list of packet types we will receive (as opposed to discard)
171 * and the routines to invoke.
172 @@ -1296,6 +1346,10 @@
173 skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
174 #endif
175 if (q->enqueue) {
176 +#if defined (CONFIG_RING) || defined(CONFIG_RING_MODULE)
177 + if(ring_handler) ring_handler(skb, 0, 1);
178 +#endif /* CONFIG_RING */
179 +
180 /* Grab device queue */
181 spin_lock(&dev->queue_lock);
182
183 @@ -1437,6 +1491,13 @@
184
185 preempt_disable();
186 err = netif_rx(skb);
187 +#if defined (CONFIG_RING) || defined(CONFIG_RING_MODULE)
188 + if(ring_handler && ring_handler(skb, 1, 1)) {
189 + /* The packet has been copied into a ring */
190 + return(NET_RX_SUCCESS);
191 + }
192 +#endif /* CONFIG_RING */
193 +
194 if (local_softirq_pending())
195 do_softirq();
196 preempt_enable();
197 @@ -1582,6 +1643,13 @@
198 struct net_device *orig_dev;
199 int ret = NET_RX_DROP;
200 unsigned short type;
201 +#if defined (CONFIG_RING) || defined(CONFIG_RING_MODULE)
202 + if(ring_handler && ring_handler(skb, 1, 1)) {
203 + /* The packet has been copied into a ring */
204 + return(NET_RX_SUCCESS);
205 + }
206 +#endif /* CONFIG_RING */
207 +
208
209 /* if we've gotten here through NAPI, check netpoll */
210 if (skb->dev->poll && netpoll_rx(skb))
211 diff --unified --recursive --new-file linux-2.6.15-rc6/net/Kconfig linux-2.6.15-rc6-1-686-smp-ring3/net/Kconfig
212 --- linux-2.6.15-rc6/net/Kconfig 2005-12-19 01:36:54.000000000 +0100
213 +++ linux-2.6.15-rc6-1-686-smp-ring3/net/Kconfig 2005-12-24 00:24:02.000000000 +0100
214 @@ -31,6 +31,7 @@
215 source "net/unix/Kconfig"
216 source "net/xfrm/Kconfig"
217
218 +source "net/ring/Kconfig"
219 config INET
220 bool "TCP/IP networking"
221 ---help---
222 diff --unified --recursive --new-file linux-2.6.15-rc6/net/Makefile linux-2.6.15-rc6-1-686-smp-ring3/net/Makefile
223 --- linux-2.6.15-rc6/net/Makefile 2005-12-19 01:36:54.000000000 +0100
224 +++ linux-2.6.15-rc6-1-686-smp-ring3/net/Makefile 2005-12-24 00:24:02.000000000 +0100
225 @@ -42,6 +42,7 @@
226 obj-$(CONFIG_DECNET) += decnet/
227 obj-$(CONFIG_ECONET) += econet/
228 obj-$(CONFIG_VLAN_8021Q) += 8021q/
229 +obj-$(CONFIG_RING) += ring/
230 obj-$(CONFIG_IP_DCCP) += dccp/
231 obj-$(CONFIG_IP_SCTP) += sctp/
232 obj-$(CONFIG_IEEE80211) += ieee80211/
233 diff --unified --recursive --new-file linux-2.6.15-rc6/net/ring/Kconfig linux-2.6.15-rc6-1-686-smp-ring3/net/ring/Kconfig
234 --- linux-2.6.15-rc6/net/ring/Kconfig 1970-01-01 01:00:00.000000000 +0100
235 +++ linux-2.6.15-rc6-1-686-smp-ring3/net/ring/Kconfig 2005-12-24 00:24:02.000000000 +0100
236 @@ -0,0 +1,14 @@
237 +config RING
238 + tristate "PF_RING sockets (EXPERIMENTAL)"
239 + depends on EXPERIMENTAL
240 + ---help---
241 + PF_RING socket family, optimized for packet capture.
242 + If a PF_RING socket is bound to an adapter (via the bind() system
243 + call), such adapter will be used in read-only mode until the socket
244 + is destroyed. Whenever an incoming packet is received from the adapter
245 + it will not passed to upper layers, but instead it is copied to a ring
246 + buffer, which in turn is exported to user space applications via mmap.
247 + Please refer to http://luca.ntop.org/Ring.pdf for more.
248 +
249 + Say N unless you know what you are doing.
250 +
251 diff --unified --recursive --new-file linux-2.6.15-rc6/net/ring/Makefile linux-2.6.15-rc6-1-686-smp-ring3/net/ring/Makefile
252 --- linux-2.6.15-rc6/net/ring/Makefile 1970-01-01 01:00:00.000000000 +0100
253 +++ linux-2.6.15-rc6-1-686-smp-ring3/net/ring/Makefile 2005-12-24 00:24:02.000000000 +0100
254 @@ -0,0 +1,7 @@
255 +#
256 +# Makefile for the ring driver.
257 +#
258 +
259 +obj-m += ring.o
260 +
261 +ring-objs := ring_packet.o
262 diff --unified --recursive --new-file linux-2.6.15-rc6/net/ring/ring_packet.c linux-2.6.15-rc6-1-686-smp-ring3/net/ring/ring_packet.c
263 --- linux-2.6.15-rc6/net/ring/ring_packet.c 1970-01-01 01:00:00.000000000 +0100
264 +++ linux-2.6.15-rc6-1-686-smp-ring3/net/ring/ring_packet.c 2005-12-24 00:24:02.000000000 +0100
265 @@ -0,0 +1,1568 @@
266 +/*
267 + *
268 + * (C) 2004-05 - Luca Deri <deri@ntop.org>
269 + *
270 + * This code includes contributions courtesy of
271 + * - Jeff Randall <jrandall@nexvu.com>
272 + * - Helmut Manck <helmut.manck@secunet.com>
273 + * - Brad Doctor <brad@stillsecure.com>
274 + * - Amit D. Chaudhary <amit_ml@rajgad.com>
275 + *
276 + */
277 +
278 +/*
279 + TO DO:
280 + add an entry inside the /proc filesystem
281 +*/
282 +
283 +#include <linux/version.h>
284 +#include <linux/config.h>
285 +#include <linux/module.h>
286 +#include <linux/kernel.h>
287 +#include <linux/socket.h>
288 +#include <linux/skbuff.h>
289 +#include <linux/rtnetlink.h>
290 +#include <linux/in.h>
291 +#include <linux/in6.h>
292 +#include <linux/init.h>
293 +#include <linux/filter.h>
294 +#include <linux/ring.h>
295 +#include <linux/ip.h>
296 +#include <linux/tcp.h>
297 +#include <linux/udp.h>
298 +#include <linux/list.h>
299 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
300 +#include <net/xfrm.h>
301 +#else
302 +#include <linux/poll.h>
303 +#endif
304 +#include <net/sock.h>
305 +#include <asm/io.h> /* needed for virt_to_phys() */
306 +
307 +/* #define RING_DEBUG */
308 +
309 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,11))
310 +static inline int remap_page_range(struct vm_area_struct *vma,
311 + unsigned long uvaddr,
312 + unsigned long paddr,
313 + unsigned long size,
314 + pgprot_t prot) {
315 + return(remap_pfn_range(vma, uvaddr, paddr >> PAGE_SHIFT,
316 + size, prot));
317 +}
318 +#endif
319 +
320 +/* ************************************************* */
321 +
322 +#define CLUSTER_LEN 8
323 +
324 +struct ring_cluster {
325 + u_short cluster_id; /* 0 = no cluster */
326 + u_short num_cluster_elements;
327 + enum cluster_type hashing_mode;
328 + u_short hashing_id;
329 + struct sock *sk[CLUSTER_LEN];
330 + struct ring_cluster *next; /* NULL = last element of the cluster */
331 +};
332 +
333 +/* ************************************************* */
334 +
335 +struct ring_element {
336 + struct list_head list;
337 + struct sock *sk;
338 +};
339 +
340 +/* ************************************************* */
341 +
342 +struct ring_opt {
343 + struct net_device *ring_netdev;
344 +
345 + /* Cluster */
346 + u_short cluster_id; /* 0 = no cluster */
347 +
348 + /* Reflector */
349 + struct net_device *reflector_dev;
350 +
351 + /* Packet buffers */
352 + unsigned long order;
353 +
354 + /* Ring Slots */
355 + unsigned long ring_memory;
356 + FlowSlotInfo *slots_info; /* Basically it points to ring_memory */
357 + char *ring_slots; /* Basically it points to ring_memory
358 + +sizeof(FlowSlotInfo) */
359 +
360 + /* Packet Sampling */
361 + u_int pktToSample, sample_rate;
362 +
363 + /* BPF Filter */
364 + struct sk_filter *bpfFilter;
365 +
366 + /* Locks */
367 + atomic_t num_ring_slots_waiters;
368 + wait_queue_head_t ring_slots_waitqueue;
369 + rwlock_t ring_index_lock;
370 +
371 + /* Indexes (Internal) */
372 + u_int insert_page_id, insert_slot_id;
373 +};
374 +
375 +/* ************************************************* */
376 +
377 +/* List of all ring sockets. */
378 +static struct list_head ring_table;
379 +
380 +/* List of all clusters */
381 +static struct ring_cluster *ring_cluster_list;
382 +
383 +static rwlock_t ring_mgmt_lock = RW_LOCK_UNLOCKED;
384 +
385 +/* ********************************** */
386 +
387 +/* Forward */
388 +static struct proto_ops ring_ops;
389 +
390 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,11))
391 +static struct proto ring_proto;
392 +#endif
393 +
394 +static int skb_ring_handler(struct sk_buff *skb, u_char recv_packet,
395 + u_char real_skb);
396 +static int buffer_ring_handler(struct net_device *dev, char *data, int len);
397 +static int remove_from_cluster(struct sock *sock, struct ring_opt *pfr);
398 +
399 +/* Extern */
400 +
401 +/* ********************************** */
402 +
403 +/* Defaults */
404 +static u_int bucket_len = 128, num_slots = 4096, sample_rate = 1,
405 + transparent_mode = 1, enable_tx_capture = 0;
406 +
407 +MODULE_PARM(bucket_len, "i");
408 +MODULE_PARM_DESC(bucket_len, "Number of ring buckets");
409 +MODULE_PARM(num_slots, "i");
410 +MODULE_PARM_DESC(num_slots, "Number of ring slots");
411 +MODULE_PARM(sample_rate, "i");
412 +MODULE_PARM_DESC(sample_rate, "Ring packet sample rate");
413 +MODULE_PARM(transparent_mode, "i");
414 +MODULE_PARM_DESC(transparent_mode,
415 + "Set to 1 to set transparent mode "
416 + "(slower but backwards compatible)");
417 +MODULE_PARM(enable_tx_capture, "i");
418 +MODULE_PARM_DESC(enable_tx_capture, "Set to 1 to capture outgoing packets");
419 +
420 +/* ********************************** */
421 +
422 +#define MIN_QUEUED_PKTS 64
423 +#define MAX_QUEUE_LOOPS 64
424 +
425 +
426 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
427 +#define ring_sk_datatype(__sk) ((struct ring_opt *)__sk)
428 +#define ring_sk(__sk) ((__sk)->sk_protinfo)
429 +#else
430 +#define ring_sk_datatype(a) (a)
431 +#define ring_sk(__sk) ((__sk)->protinfo.pf_ring)
432 +#endif
433 +
434 +#define _rdtsc() ({ uint64_t x; asm volatile("rdtsc" : "=A" (x)); x; })
435 +
436 +/*
437 + int dev_queue_xmit(struct sk_buff *skb)
438 + skb->dev;
439 + struct net_device *dev_get_by_name(const char *name)
440 +*/
441 +
442 +/* ********************************** */
443 +
444 +static void ring_sock_destruct(struct sock *sk) {
445 +
446 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
447 + skb_queue_purge(&sk->sk_receive_queue);
448 +
449 + if (!sock_flag(sk, SOCK_DEAD)) {
450 +#if defined(RING_DEBUG)
451 + printk("Attempt to release alive ring socket: %p\n", sk);
452 +#endif
453 + return;
454 + }
455 +
456 + BUG_TRAP(!atomic_read(&sk->sk_rmem_alloc));
457 + BUG_TRAP(!atomic_read(&sk->sk_wmem_alloc));
458 +#else
459 +
460 + BUG_TRAP(atomic_read(&sk->rmem_alloc)==0);
461 + BUG_TRAP(atomic_read(&sk->wmem_alloc)==0);
462 +
463 + if (!sk->dead) {
464 +#if defined(RING_DEBUG)
465 + printk("Attempt to release alive ring socket: %p\n", sk);
466 +#endif
467 + return;
468 + }
469 +#endif
470 +
471 + kfree(ring_sk(sk));
472 +
473 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
474 + MOD_DEC_USE_COUNT;
475 +#endif
476 +}
477 +
478 +/* ********************************** */
479 +/*
480 + * ring_insert()
481 + *
482 + * store the sk in a new element and add it
483 + * to the head of the list.
484 + */
485 +static inline void ring_insert(struct sock *sk) {
486 + struct ring_element *next;
487 +
488 +#if defined(RING_DEBUG)
489 + printk("RING: ring_insert()\n");
490 +#endif
491 +
492 + next = kmalloc(sizeof(struct ring_element), GFP_ATOMIC);
493 + if(next != NULL) {
494 + next->sk = sk;
495 + write_lock_irq(&ring_mgmt_lock);
496 + list_add(&next->list, &ring_table);
497 + write_unlock_irq(&ring_mgmt_lock);
498 + } else {
499 + if (net_ratelimit())
500 + printk("RING: could not kmalloc slot!!\n");
501 + }
502 +}
503 +
504 +/* ********************************** */
505 +/*
506 + * ring_remove()
507 + *
508 + * For each of the elements in the list:
509 + * - check if this is the element we want to delete
510 + * - if it is, remove it from the list, and free it.
511 + *
512 + * stop when we find the one we're looking for (break),
513 + * or when we reach the end of the list.
514 + */
515 +static inline void ring_remove(struct sock *sk) {
516 + struct list_head *ptr;
517 + struct ring_element *entry;
518 +
519 +
520 + for(ptr = ring_table.next; ptr != &ring_table; ptr = ptr->next) {
521 + entry = list_entry(ptr, struct ring_element, list);
522 +
523 + if(entry->sk == sk) {
524 + write_lock_irq(&ring_mgmt_lock);
525 + list_del(ptr);
526 + kfree(ptr);
527 + write_unlock_irq(&ring_mgmt_lock);
528 + break;
529 + }
530 + }
531 +
532 +}
533 +
534 +/* ********************************** */
535 +
536 +static u_int32_t num_queued_pkts(struct ring_opt *pfr) {
537 +
538 + if(pfr->ring_slots != NULL) {
539 +
540 + u_int32_t tot_insert = pfr->slots_info->insert_idx,
541 +#if defined(RING_DEBUG)
542 + tot_read = pfr->slots_info->tot_read, tot_pkts;
543 +#else
544 + tot_read = pfr->slots_info->tot_read;
545 +#endif
546 +
547 + if(tot_insert >= tot_read) {
548 +#if defined(RING_DEBUG)
549 + tot_pkts = tot_insert-tot_read;
550 +#endif
551 + return(tot_insert-tot_read);
552 + } else {
553 +#if defined(RING_DEBUG)
554 + tot_pkts = ((u_int32_t)-1)+tot_insert-tot_read;
555 +#endif
556 + return(((u_int32_t)-1)+tot_insert-tot_read);
557 + }
558 +
559 +#if defined(RING_DEBUG)
560 + printk("-> num_queued_pkts=%d [tot_insert=%d][tot_read=%d]\n",
561 + tot_pkts, tot_insert, tot_read);
562 +#endif
563 +
564 + } else
565 + return(0);
566 +}
567 +
568 +/* ********************************** */
569 +
570 +static inline FlowSlot* get_insert_slot(struct ring_opt *pfr) {
571 +#if defined(RING_DEBUG)
572 + printk("get_insert_slot(%d)\n", pfr->slots_info->insert_idx);
573 +#endif
574 +
575 + if(pfr->ring_slots != NULL) {
576 + FlowSlot *slot = (FlowSlot*)&(pfr->ring_slots[pfr->slots_info->insert_idx
577 + *pfr->slots_info->slot_len]);
578 + return(slot);
579 + } else
580 + return(NULL);
581 +}
582 +
583 +/* ********************************** */
584 +
585 +static inline FlowSlot* get_remove_slot(struct ring_opt *pfr) {
586 +#if defined(RING_DEBUG)
587 + printk("get_remove_slot(%d)\n", pfr->slots_info->remove_idx);
588 +#endif
589 +
590 + if(pfr->ring_slots != NULL)
591 + return((FlowSlot*)&(pfr->ring_slots[pfr->slots_info->remove_idx*
592 + pfr->slots_info->slot_len]));
593 + else
594 + return(NULL);
595 +}
596 +
597 +/* ********************************** */
598 +
599 +static void add_skb_to_ring(struct sk_buff *skb,
600 + struct ring_opt *pfr,
601 + u_char recv_packet,
602 + u_char real_skb /* 1=skb 0=faked skb */) {
603 + FlowSlot *theSlot;
604 + int idx, displ;
605 +
606 + if(recv_packet) {
607 + /* Hack for identifying a packet received by the e1000 */
608 + if(real_skb) {
609 + displ = SKB_DISPLACEMENT;
610 + } else
611 + displ = 0; /* Received by the e1000 wrapper */
612 + } else
613 + displ = 0;
614 +
615 + write_lock(&pfr->ring_index_lock);
616 + pfr->slots_info->tot_pkts++;
617 + write_unlock(&pfr->ring_index_lock);
618 +
619 + /* BPF Filtering (from af_packet.c) */
620 + if(pfr->bpfFilter != NULL) {
621 + unsigned res = 1, len;
622 +
623 + len = skb->len-skb->data_len;
624 +
625 + write_lock(&pfr->ring_index_lock);
626 + skb->data -= displ;
627 + res = sk_run_filter(skb, pfr->bpfFilter->insns, pfr->bpfFilter->len);
628 + skb->data += displ;
629 + write_unlock(&pfr->ring_index_lock);
630 +
631 + if(res == 0) {
632 + /* Filter failed */
633 +
634 +#if defined(RING_DEBUG)
635 + printk("add_skb_to_ring(skb): Filter failed [len=%d][tot=%llu]"
636 + "[insertIdx=%d][pkt_type=%d][cloned=%d]\n",
637 + (int)skb->len, pfr->slots_info->tot_pkts,
638 + pfr->slots_info->insert_idx,
639 + skb->pkt_type, skb->cloned);
640 +#endif
641 +
642 + return;
643 + }
644 + }
645 +
646 + /* ************************** */
647 +
648 + if(pfr->sample_rate > 1) {
649 + if(pfr->pktToSample == 0) {
650 + write_lock(&pfr->ring_index_lock);
651 + pfr->pktToSample = pfr->sample_rate;
652 + write_unlock(&pfr->ring_index_lock);
653 + } else {
654 + write_lock(&pfr->ring_index_lock);
655 + pfr->pktToSample--;
656 + write_unlock(&pfr->ring_index_lock);
657 +
658 +#if defined(RING_DEBUG)
659 + printk("add_skb_to_ring(skb): sampled packet [len=%d]"
660 + "[tot=%llu][insertIdx=%d][pkt_type=%d][cloned=%d]\n",
661 + (int)skb->len, pfr->slots_info->tot_pkts,
662 + pfr->slots_info->insert_idx,
663 + skb->pkt_type, skb->cloned);
664 +#endif
665 + return;
666 + }
667 + }
668 +
669 + /* ************************************* */
670 +
671 + if((pfr->reflector_dev != NULL)
672 + && (!netif_queue_stopped(pfr->reflector_dev))) {
673 + int cpu = smp_processor_id();
674 +
675 + /* increase reference counter so that this skb is not freed */
676 + atomic_inc(&skb->users);
677 +
678 + skb->data -= displ;
679 +
680 + /* send it */
681 + if (pfr->reflector_dev->xmit_lock_owner != cpu) {
682 + spin_lock_bh(&pfr->reflector_dev->xmit_lock);
683 + pfr->reflector_dev->xmit_lock_owner = cpu;
684 + spin_unlock_bh(&pfr->reflector_dev->xmit_lock);
685 +
686 + if (pfr->reflector_dev->hard_start_xmit(skb,
687 + pfr->reflector_dev) == 0) {
688 + spin_lock_bh(&pfr->reflector_dev->xmit_lock);
689 + pfr->reflector_dev->xmit_lock_owner = -1;
690 + skb->data += displ;
691 + spin_unlock_bh(&pfr->reflector_dev->xmit_lock);
692 +#if defined(RING_DEBUG)
693 + printk("++ hard_start_xmit succeeded\n");
694 +#endif
695 + return; /* OK */
696 + }
697 +
698 + spin_lock_bh(&pfr->reflector_dev->xmit_lock);
699 + pfr->reflector_dev->xmit_lock_owner = -1;
700 + spin_unlock_bh(&pfr->reflector_dev->xmit_lock);
701 + }
702 +
703 +#if defined(RING_DEBUG)
704 + printk("++ hard_start_xmit failed\n");
705 +#endif
706 + skb->data += displ;
707 + return; /* -ENETDOWN */
708 + }
709 +
710 + /* ************************************* */
711 +
712 +#if defined(RING_DEBUG)
713 + printk("add_skb_to_ring(skb) [len=%d][tot=%llu][insertIdx=%d]"
714 + "[pkt_type=%d][cloned=%d]\n",
715 + (int)skb->len, pfr->slots_info->tot_pkts,
716 + pfr->slots_info->insert_idx,
717 + skb->pkt_type, skb->cloned);
718 +#endif
719 +
720 + idx = pfr->slots_info->insert_idx;
721 + theSlot = get_insert_slot(pfr);
722 +
723 + if((theSlot != NULL) && (theSlot->slot_state == 0)) {
724 + struct pcap_pkthdr *hdr;
725 + char *bucket;
726 +
727 + /* Update Index */
728 + idx++;
729 +
730 + if(idx == pfr->slots_info->tot_slots) {
731 + write_lock(&pfr->ring_index_lock);
732 + pfr->slots_info->insert_idx = 0;
733 + write_unlock(&pfr->ring_index_lock);
734 + } else {
735 + write_lock(&pfr->ring_index_lock);
736 + pfr->slots_info->insert_idx = idx;
737 + write_unlock(&pfr->ring_index_lock);
738 + }
739 +
740 + bucket = &theSlot->bucket;
741 + hdr = (struct pcap_pkthdr*)bucket;
742 +
743 + /* BD - API changed for time keeping */
744 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))
745 + if(skb->stamp.tv_sec == 0) do_gettimeofday(&skb->stamp);
746 +
747 + hdr->ts.tv_sec = skb->stamp.tv_sec, hdr->ts.tv_usec = skb->stamp.tv_usec;
748 +#else
749 + if(skb->tstamp.off_sec == 0) __net_timestamp(skb);
750 +
751 + hdr->ts.tv_sec = skb->tstamp.off_sec, hdr->ts.tv_usec = skb->tstamp.off_usec;
752 +#endif
753 +
754 + hdr->caplen = skb->len+displ;
755 +
756 + if(hdr->caplen > pfr->slots_info->data_len)
757 + hdr->caplen = pfr->slots_info->data_len;
758 +
759 + hdr->len = skb->len+displ;
760 + memcpy(&bucket[sizeof(struct pcap_pkthdr)],
761 + skb->data-displ, hdr->caplen);
762 +
763 +#if defined(RING_DEBUG)
764 + {
765 + static unsigned int lastLoss = 0;
766 +
767 + if(pfr->slots_info->tot_lost
768 + && (lastLoss != pfr->slots_info->tot_lost)) {
769 + printk("add_skb_to_ring(%d): [data_len=%d]"
770 + "[hdr.caplen=%d][skb->len=%d]"
771 + "[pcap_pkthdr=%d][removeIdx=%d]"
772 + "[loss=%lu][page=%u][slot=%u]\n",
773 + idx-1, pfr->slots_info->data_len, hdr->caplen, skb->len,
774 + sizeof(struct pcap_pkthdr),
775 + pfr->slots_info->remove_idx,
776 + (long unsigned int)pfr->slots_info->tot_lost,
777 + pfr->insert_page_id, pfr->insert_slot_id);
778 +
779 + lastLoss = pfr->slots_info->tot_lost;
780 + }
781 + }
782 +#endif
783 +
784 + write_lock(&pfr->ring_index_lock);
785 + pfr->slots_info->tot_insert++;
786 + theSlot->slot_state = 1;
787 + write_unlock(&pfr->ring_index_lock);
788 + } else {
789 + write_lock(&pfr->ring_index_lock);
790 + pfr->slots_info->tot_lost++;
791 + write_unlock(&pfr->ring_index_lock);
792 +
793 +#if defined(RING_DEBUG)
794 + printk("add_skb_to_ring(skb): packet lost [loss=%lu]"
795 + "[removeIdx=%u][insertIdx=%u]\n",
796 + (long unsigned int)pfr->slots_info->tot_lost,
797 + pfr->slots_info->remove_idx, pfr->slots_info->insert_idx);
798 +#endif
799 + }
800 +
801 + /* wakeup in case of poll() */
802 + if(waitqueue_active(&pfr->ring_slots_waitqueue))
803 + wake_up_interruptible(&pfr->ring_slots_waitqueue);
804 +}
805 +
806 +/* ********************************** */
807 +
808 +static u_int hash_skb(struct ring_cluster *cluster_ptr,
809 + struct sk_buff *skb, u_char recv_packet) {
810 + u_int idx;
811 + int displ;
812 + struct iphdr *ip;
813 +
814 + if(cluster_ptr->hashing_mode == cluster_round_robin) {
815 + idx = cluster_ptr->hashing_id++;
816 + } else {
817 + /* Per-flow clustering */
818 + if(skb->len > sizeof(struct iphdr)+sizeof(struct tcphdr)) {
819 + if(recv_packet)
820 + displ = 0;
821 + else
822 + displ = SKB_DISPLACEMENT;
823 +
824 + /*
825 + skb->data+displ
826 +
827 + Always points to to the IP part of the packet
828 + */
829 +
830 + ip = (struct iphdr*)(skb->data+displ);
831 +
832 + idx = ip->saddr+ip->daddr+ip->protocol;
833 +
834 + if(ip->protocol == IPPROTO_TCP) {
835 + struct tcphdr *tcp = (struct tcphdr*)(skb->data+displ
836 + +sizeof(struct iphdr));
837 + idx += tcp->source+tcp->dest;
838 + } else if(ip->protocol == IPPROTO_UDP) {
839 + struct udphdr *udp = (struct udphdr*)(skb->data+displ
840 + +sizeof(struct iphdr));
841 + idx += udp->source+udp->dest;
842 + }
843 + } else
844 + idx = skb->len;
845 + }
846 +
847 + return(idx % cluster_ptr->num_cluster_elements);
848 +}
849 +
850 +/* ********************************** */
851 +
852 +static int skb_ring_handler(struct sk_buff *skb,
853 + u_char recv_packet,
854 + u_char real_skb /* 1=skb 0=faked skb */) {
855 + struct sock *skElement;
856 + int rc = 0;
857 + struct list_head *ptr;
858 + struct ring_cluster *cluster_ptr;
859 +
860 +#ifdef PROFILING
861 + uint64_t rdt = _rdtsc(), rdt1, rdt2;
862 +#endif
863 +
864 + if((!skb) /* Invalid skb */
865 + || ((!enable_tx_capture) && (!recv_packet))) {
866 + /*
867 + An outgoing packet is about to be sent out
868 + but we decided not to handle transmitted
869 + packets.
870 + */
871 + return(0);
872 + }
873 +
874 +#if defined(RING_DEBUG)
875 + if(0) {
876 + printk("skb_ring_handler() [len=%d][dev=%s]\n", skb->len,
877 + skb->dev->name == NULL ? "<NULL>" : skb->dev->name);
878 + }
879 +#endif
880 +
881 +#ifdef PROFILING
882 + rdt1 = _rdtsc();
883 +#endif
884 +
885 + /* [1] Check unclustered sockets */
886 + for (ptr = ring_table.next; ptr != &ring_table; ptr = ptr->next) {
887 + struct ring_opt *pfr;
888 + struct ring_element *entry;
889 +
890 + entry = list_entry(ptr, struct ring_element, list);
891 +
892 + read_lock(&ring_mgmt_lock);
893 + skElement = entry->sk;
894 + pfr = ring_sk(skElement);
895 + read_unlock(&ring_mgmt_lock);
896 +
897 + if((pfr != NULL)
898 + && (pfr->cluster_id == 0 /* No cluster */)
899 + && (pfr->ring_slots != NULL)
900 + && (pfr->ring_netdev == skb->dev)) {
901 + /* We've found the ring where the packet can be stored */
902 + read_lock(&ring_mgmt_lock);
903 + add_skb_to_ring(skb, pfr, recv_packet, real_skb);
904 + read_unlock(&ring_mgmt_lock);
905 +
906 + rc = 1; /* Ring found: we've done our job */
907 + }
908 + }
909 +
910 + /* [2] Check socket clusters */
911 + cluster_ptr = ring_cluster_list;
912 +
913 + while(cluster_ptr != NULL) {
914 + struct ring_opt *pfr;
915 +
916 + if(cluster_ptr->num_cluster_elements > 0) {
917 + u_int skb_hash = hash_skb(cluster_ptr, skb, recv_packet);
918 +
919 + read_lock(&ring_mgmt_lock);
920 + skElement = cluster_ptr->sk[skb_hash];
921 + read_unlock(&ring_mgmt_lock);
922 +
923 + if(skElement != NULL) {
924 + pfr = ring_sk(skElement);
925 +
926 + if((pfr != NULL)
927 + && (pfr->ring_slots != NULL)
928 + && (pfr->ring_netdev == skb->dev)) {
929 + /* We've found the ring where the packet can be stored */
930 + read_lock(&ring_mgmt_lock);
931 + add_skb_to_ring(skb, pfr, recv_packet, real_skb);
932 + read_unlock(&ring_mgmt_lock);
933 +
934 + rc = 1; /* Ring found: we've done our job */
935 + }
936 + }
937 + }
938 +
939 + cluster_ptr = cluster_ptr->next;
940 + }
941 +
942 +#ifdef PROFILING
943 + rdt1 = _rdtsc()-rdt1;
944 +#endif
945 +
946 +#ifdef PROFILING
947 + rdt2 = _rdtsc();
948 +#endif
949 +
950 + if(transparent_mode) rc = 0;
951 +
952 + if((rc != 0) && real_skb)
953 + dev_kfree_skb(skb); /* Free the skb */
954 +
955 +#ifdef PROFILING
956 + rdt2 = _rdtsc()-rdt2;
957 + rdt = _rdtsc()-rdt;
958 +
959 +#if defined(RING_DEBUG)
960 + printk("# cycles: %d [lock costed %d %d%%][free costed %d %d%%]\n",
961 + (int)rdt, rdt-rdt1,
962 + (int)((float)((rdt-rdt1)*100)/(float)rdt),
963 + rdt2,
964 + (int)((float)(rdt2*100)/(float)rdt));
965 +#endif
966 +#endif
967 +
968 + return(rc); /* 0 = packet not handled */
969 +}
970 +
971 +/* ********************************** */
972 +
973 +struct sk_buff skb;
974 +
975 +static int buffer_ring_handler(struct net_device *dev,
976 + char *data, int len) {
977 +
978 +#if defined(RING_DEBUG)
979 + printk("buffer_ring_handler: [dev=%s][len=%d]\n",
980 + dev->name == NULL ? "<NULL>" : dev->name, len);
981 +#endif
982 +
983 + /* BD - API changed for time keeping */
984 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))
985 + skb.dev = dev, skb.len = len, skb.data = data,
986 + skb.data_len = len, skb.stamp.tv_sec = 0; /* Calculate the time */
987 +#else
988 + skb.dev = dev, skb.len = len, skb.data = data,
989 + skb.data_len = len, skb.tstamp.off_sec = 0; /* Calculate the time */
990 +#endif
991 +
992 + skb_ring_handler(&skb, 1, 0 /* fake skb */);
993 +
994 + return(0);
995 +}
996 +
997 +/* ********************************** */
998 +
999 +static int ring_create(struct socket *sock, int protocol) {
1000 + struct sock *sk;
1001 + struct ring_opt *pfr;
1002 + int err;
1003 +
1004 +#if defined(RING_DEBUG)
1005 + printk("RING: ring_create()\n");
1006 +#endif
1007 +
1008 + /* Are you root, superuser or so ? */
1009 + if(!capable(CAP_NET_ADMIN))
1010 + return -EPERM;
1011 +
1012 + if(sock->type != SOCK_RAW)
1013 + return -ESOCKTNOSUPPORT;
1014 +
1015 + if(protocol != htons(ETH_P_ALL))
1016 + return -EPROTONOSUPPORT;
1017 +
1018 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
1019 + MOD_INC_USE_COUNT;
1020 +#endif
1021 +
1022 + err = -ENOMEM;
1023 +
1024 + // BD: -- broke this out to keep it more simple and clear as to what the
1025 + // options are.
1026 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
1027 +#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11))
1028 + sk = sk_alloc(PF_RING, GFP_KERNEL, 1, NULL);
1029 +#else
1030 + // BD: API changed in 2.6.12, ref:
1031 + // http://svn.clkao.org/svnweb/linux/revision/?rev=28201
1032 + sk = sk_alloc(PF_RING, GFP_ATOMIC, &ring_proto, 1);
1033 +#endif
1034 +#else
1035 + /* Kernel 2.4 */
1036 + sk = sk_alloc(PF_RING, GFP_KERNEL, 1);
1037 +#endif
1038 +
1039 + if (sk == NULL)
1040 + goto out;
1041 +
1042 + sock->ops = &ring_ops;
1043 + sock_init_data(sock, sk);
1044 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
1045 +#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11))
1046 + sk_set_owner(sk, THIS_MODULE);
1047 +#endif
1048 +#endif
1049 +
1050 + err = -ENOMEM;
1051 + ring_sk(sk) = ring_sk_datatype(kmalloc(sizeof(*pfr), GFP_KERNEL));
1052 +
1053 + if (!(pfr = ring_sk(sk))) {
1054 + sk_free(sk);
1055 + goto out;
1056 + }
1057 + memset(pfr, 0, sizeof(*pfr));
1058 + init_waitqueue_head(&pfr->ring_slots_waitqueue);
1059 + pfr->ring_index_lock = RW_LOCK_UNLOCKED;
1060 + atomic_set(&pfr->num_ring_slots_waiters, 0);
1061 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
1062 + sk->sk_family = PF_RING;
1063 + sk->sk_destruct = ring_sock_destruct;
1064 +#else
1065 + sk->family = PF_RING;
1066 + sk->destruct = ring_sock_destruct;
1067 + sk->num = protocol;
1068 +#endif
1069 +
1070 + ring_insert(sk);
1071 +
1072 +#if defined(RING_DEBUG)
1073 + printk("RING: ring_create() - created\n");
1074 +#endif
1075 +
1076 + return(0);
1077 + out:
1078 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
1079 + MOD_DEC_USE_COUNT;
1080 +#endif
1081 + return err;
1082 +}
1083 +
1084 +/* *********************************************** */
1085 +
1086 +static int ring_release(struct socket *sock)
1087 +{
1088 + struct sock *sk = sock->sk;
1089 + struct ring_opt *pfr = ring_sk(sk);
1090 +
1091 + if(!sk)
1092 + return 0;
1093 +
1094 +#if defined(RING_DEBUG)
1095 + printk("RING: called ring_release\n");
1096 +#endif
1097 +
1098 +#if defined(RING_DEBUG)
1099 + printk("RING: ring_release entered\n");
1100 +#endif
1101 +
1102 + ring_remove(sk);
1103 +
1104 + sock_orphan(sk);
1105 + sock->sk = NULL;
1106 +
1107 + /* Free the ring buffer */
1108 + if(pfr->ring_memory) {
1109 + struct page *page, *page_end;
1110 +
1111 + page_end = virt_to_page(pfr->ring_memory + (PAGE_SIZE << pfr->order) - 1);
1112 + for(page = virt_to_page(pfr->ring_memory); page <= page_end; page++)
1113 + ClearPageReserved(page);
1114 +
1115 + free_pages(pfr->ring_memory, pfr->order);
1116 + }
1117 +
1118 + kfree(pfr);
1119 + ring_sk(sk) = NULL;
1120 +
1121 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
1122 + skb_queue_purge(&sk->sk_write_queue);
1123 +#endif
1124 + sock_put(sk);
1125 +
1126 +#if defined(RING_DEBUG)
1127 + printk("RING: ring_release leaving\n");
1128 +#endif
1129 +
1130 + return 0;
1131 +}
1132 +
1133 +/* ********************************** */
1134 +/*
1135 + * We create a ring for this socket and bind it to the specified device
1136 + */
1137 +static int packet_ring_bind(struct sock *sk, struct net_device *dev)
1138 +{
1139 + u_int the_slot_len;
1140 + u_int32_t tot_mem;
1141 + struct ring_opt *pfr = ring_sk(sk);
1142 + struct page *page, *page_end;
1143 +
1144 + if(!dev) return(-1);
1145 +
1146 +#if defined(RING_DEBUG)
1147 + printk("RING: packet_ring_bind(%s) called\n", dev->name);
1148 +#endif
1149 +
1150 + /* **********************************************
1151 +
1152 + *************************************
1153 + * *
1154 + * FlowSlotInfo *
1155 + * *
1156 + ************************************* <-+
1157 + * FlowSlot * |
1158 + ************************************* |
1159 + * FlowSlot * |
1160 + ************************************* +- num_slots
1161 + * FlowSlot * |
1162 + ************************************* |
1163 + * FlowSlot * |
1164 + ************************************* <-+
1165 +
1166 + ********************************************** */
1167 +
1168 + the_slot_len = sizeof(u_char) /* flowSlot.slot_state */
1169 +#ifdef RING_MAGIC
1170 + + sizeof(u_char)
1171 +#endif
1172 + + sizeof(struct pcap_pkthdr)
1173 + + bucket_len /* flowSlot.bucket */;
1174 +
1175 + tot_mem = sizeof(FlowSlotInfo) + num_slots*the_slot_len;
1176 +
1177 + /*
1178 + Calculate the value of the order parameter used later.
1179 + See http://www.linuxjournal.com/article.php?sid=1133
1180 + */
1181 + for(pfr->order = 0;(PAGE_SIZE << pfr->order) < tot_mem; pfr->order++) ;
1182 +
1183 + /*
1184 + We now try to allocate the memory as required. If we fail
1185 + we try to allocate a smaller amount or memory (hence a
1186 + smaller ring).
1187 + */
1188 + while((pfr->ring_memory = __get_free_pages(GFP_ATOMIC, pfr->order)) == 0)
1189 + if(pfr->order-- == 0)
1190 + break;
1191 +
1192 + if(pfr->order == 0) {
1193 + printk("RING: ERROR not enough memory for ring\n");
1194 + return(-1);
1195 + } else {
1196 + printk("RING: succesfully allocated %lu KB [tot_mem=%d][order=%ld]\n",
1197 + PAGE_SIZE >> (10 - pfr->order), tot_mem, pfr->order);
1198 + }
1199 +
1200 + tot_mem = PAGE_SIZE << pfr->order;
1201 + memset((char*)pfr->ring_memory, 0, tot_mem);
1202 +
1203 + /* Now we need to reserve the pages */
1204 + page_end = virt_to_page(pfr->ring_memory + (PAGE_SIZE << pfr->order) - 1);
1205 + for(page = virt_to_page(pfr->ring_memory); page <= page_end; page++)
1206 + SetPageReserved(page);
1207 +
1208 + pfr->slots_info = (FlowSlotInfo*)pfr->ring_memory;
1209 + pfr->ring_slots = (char*)(pfr->ring_memory+sizeof(FlowSlotInfo));
1210 +
1211 + pfr->slots_info->version = RING_FLOWSLOT_VERSION;
1212 + pfr->slots_info->slot_len = the_slot_len;
1213 + pfr->slots_info->data_len = bucket_len;
1214 + pfr->slots_info->tot_slots = (tot_mem-sizeof(FlowSlotInfo))/the_slot_len;
1215 + pfr->slots_info->tot_mem = tot_mem;
1216 + pfr->slots_info->sample_rate = sample_rate;
1217 +
1218 + printk("RING: allocated %d slots [slot_len=%d][tot_mem=%u]\n",
1219 + pfr->slots_info->tot_slots, pfr->slots_info->slot_len,
1220 + pfr->slots_info->tot_mem);
1221 +
1222 +#ifdef RING_MAGIC
1223 + {
1224 + int i;
1225 +
1226 + for(i=0; i<pfr->slots_info->tot_slots; i++) {
1227 + unsigned long idx = i*pfr->slots_info->slot_len;
1228 + FlowSlot *slot = (FlowSlot*)&pfr->ring_slots[idx];
1229 + slot->magic = RING_MAGIC_VALUE; slot->slot_state = 0;
1230 + }
1231 + }
1232 +#endif
1233 +
1234 + pfr->insert_page_id = 1, pfr->insert_slot_id = 0;
1235 +
1236 + /*
1237 + IMPORTANT
1238 + Leave this statement here as last one. In fact when
1239 + the ring_netdev != NULL the socket is ready to be used.
1240 + */
1241 + pfr->ring_netdev = dev;
1242 +
1243 + return(0);
1244 +}
1245 +
1246 +/* ************************************* */
1247 +
1248 +/* Bind to a device */
1249 +static int ring_bind(struct socket *sock,
1250 + struct sockaddr *sa, int addr_len)
1251 +{
1252 + struct sock *sk=sock->sk;
1253 + struct net_device *dev = NULL;
1254 +
1255 +#if defined(RING_DEBUG)
1256 + printk("RING: ring_bind() called\n");
1257 +#endif
1258 +
1259 + /*
1260 + * Check legality
1261 + */
1262 + if (addr_len != sizeof(struct sockaddr))
1263 + return -EINVAL;
1264 + if (sa->sa_family != PF_RING)
1265 + return -EINVAL;
1266 +
1267 + /* Safety check: add trailing zero if missing */
1268 + sa->sa_data[sizeof(sa->sa_data)-1] = '\0';
1269 +
1270 +#if defined(RING_DEBUG)
1271 + printk("RING: searching device %s\n", sa->sa_data);
1272 +#endif
1273 +
1274 + if((dev = __dev_get_by_name(sa->sa_data)) == NULL) {
1275 +#if defined(RING_DEBUG)
1276 + printk("RING: search failed\n");
1277 +#endif
1278 + return(-EINVAL);
1279 + } else
1280 + return(packet_ring_bind(sk, dev));
1281 +}
1282 +
1283 +/* ************************************* */
1284 +
1285 +static int ring_mmap(struct file *file,
1286 + struct socket *sock,
1287 + struct vm_area_struct *vma)
1288 +{
1289 + struct sock *sk = sock->sk;
1290 + struct ring_opt *pfr = ring_sk(sk);
1291 + unsigned long size, start;
1292 + u_int pagesToMap;
1293 + char *ptr;
1294 +
1295 +#if defined(RING_DEBUG)
1296 + printk("RING: ring_mmap() called\n");
1297 +#endif
1298 +
1299 + if(pfr->ring_memory == 0) {
1300 +#if defined(RING_DEBUG)
1301 + printk("RING: ring_mmap() failed: mapping area to an unbound socket\n");
1302 +#endif
1303 + return -EINVAL;
1304 + }
1305 +
1306 + size = (unsigned long)(vma->vm_end-vma->vm_start);
1307 +
1308 + if(size % PAGE_SIZE) {
1309 +#if defined(RING_DEBUG)
1310 + printk("RING: ring_mmap() failed: len is not multiple of PAGE_SIZE\n");
1311 +#endif
1312 + return(-EINVAL);
1313 + }
1314 +
1315 + /* if userspace tries to mmap beyond end of our buffer, fail */
1316 + if(size > pfr->slots_info->tot_mem) {
1317 +#if defined(RING_DEBUG)
1318 + printk("proc_mmap() failed: area too large [%ld > %d]\n", size, pfr->slots_info->tot_mem);
1319 +#endif
1320 + return(-EINVAL);
1321 + }
1322 +
1323 + pagesToMap = size/PAGE_SIZE;
1324 +
1325 +#if defined(RING_DEBUG)
1326 + printk("RING: ring_mmap() called. %d pages to map\n", pagesToMap);
1327 +#endif
1328 +
1329 +#if defined(RING_DEBUG)
1330 + printk("RING: mmap [slot_len=%d][tot_slots=%d] for ring on device %s\n",
1331 + pfr->slots_info->slot_len, pfr->slots_info->tot_slots,
1332 + pfr->ring_netdev->name);
1333 +#endif
1334 +
1335 + /* we do not want to have this area swapped out, lock it */
1336 + vma->vm_flags |= VM_LOCKED;
1337 + start = vma->vm_start;
1338 +
1339 + /* Ring slots start from page 1 (page 0 is reserved for FlowSlotInfo) */
1340 + ptr = (char*)(start+PAGE_SIZE);
1341 +
1342 + if(remap_page_range(
1343 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
1344 + vma,
1345 +#endif
1346 + start,
1347 + __pa(pfr->ring_memory),
1348 + PAGE_SIZE*pagesToMap, vma->vm_page_prot)) {
1349 +#if defined(RING_DEBUG)
1350 + printk("remap_page_range() failed\n");
1351 +#endif
1352 + return(-EAGAIN);
1353 + }
1354 +
1355 +#if defined(RING_DEBUG)
1356 + printk("proc_mmap(pagesToMap=%d): success.\n", pagesToMap);
1357 +#endif
1358 +
1359 + return 0;
1360 +}
1361 +
1362 +/* ************************************* */
1363 +
1364 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
1365 +static int ring_recvmsg(struct kiocb *iocb, struct socket *sock,
1366 + struct msghdr *msg, size_t len, int flags)
1367 +#else
1368 + static int ring_recvmsg(struct socket *sock, struct msghdr *msg, int len,
1369 + int flags, struct scm_cookie *scm)
1370 +#endif
1371 +{
1372 + FlowSlot* slot;
1373 + struct ring_opt *pfr = ring_sk(sock->sk);
1374 + u_int32_t queued_pkts, num_loops = 0;
1375 +
1376 +#if defined(RING_DEBUG)
1377 + printk("ring_recvmsg called\n");
1378 +#endif
1379 +
1380 + slot = get_remove_slot(pfr);
1381 +
1382 + while((queued_pkts = num_queued_pkts(pfr)) < MIN_QUEUED_PKTS) {
1383 + wait_event_interruptible(pfr->ring_slots_waitqueue, 1);
1384 +
1385 +#if defined(RING_DEBUG)
1386 + printk("-> ring_recvmsg returning %d [queued_pkts=%d][num_loops=%d]\n",
1387 + slot->slot_state, queued_pkts, num_loops);
1388 +#endif
1389 +
1390 + if(queued_pkts > 0) {
1391 + if(num_loops++ > MAX_QUEUE_LOOPS)
1392 + break;
1393 + }
1394 + }
1395 +
1396 +#if defined(RING_DEBUG)
1397 + if(slot != NULL)
1398 + printk("ring_recvmsg is returning [queued_pkts=%d][num_loops=%d]\n",
1399 + queued_pkts, num_loops);
1400 +#endif
1401 +
1402 + return(queued_pkts);
1403 +}
1404 +
1405 +/* ************************************* */
1406 +
1407 +unsigned int ring_poll(struct file * file,
1408 + struct socket *sock, poll_table *wait)
1409 +{
1410 + FlowSlot* slot;
1411 + struct ring_opt *pfr = ring_sk(sock->sk);
1412 +
1413 +#if defined(RING_DEBUG)
1414 + printk("poll called\n");
1415 +#endif
1416 +
1417 + slot = get_remove_slot(pfr);
1418 +
1419 + if((slot != NULL) && (slot->slot_state == 0))
1420 + poll_wait(file, &pfr->ring_slots_waitqueue, wait);
1421 +
1422 +#if defined(RING_DEBUG)
1423 + printk("poll returning %d\n", slot->slot_state);
1424 +#endif
1425 +
1426 + if((slot != NULL) && (slot->slot_state == 1))
1427 + return(POLLIN | POLLRDNORM);
1428 + else
1429 + return(0);
1430 +}
1431 +
1432 +/* ************************************* */
1433 +
1434 +int add_to_cluster_list(struct ring_cluster *el,
1435 + struct sock *sock) {
1436 +
1437 + if(el->num_cluster_elements == CLUSTER_LEN)
1438 + return(-1); /* Cluster full */
1439 +
1440 + ring_sk_datatype(ring_sk(sock))->cluster_id = el->cluster_id;
1441 + el->sk[el->num_cluster_elements] = sock;
1442 + el->num_cluster_elements++;
1443 + return(0);
1444 +}
1445 +
1446 +/* ************************************* */
1447 +
1448 +int remove_from_cluster_list(struct ring_cluster *el,
1449 + struct sock *sock) {
1450 + int i, j;
1451 +
1452 + for(i=0; i<CLUSTER_LEN; i++)
1453 + if(el->sk[i] == sock) {
1454 + el->num_cluster_elements--;
1455 +
1456 + if(el->num_cluster_elements > 0) {
1457 + /* The cluster contains other elements */
1458 + for(j=i; j<CLUSTER_LEN-1; j++)
1459 + el->sk[j] = el->sk[j+1];
1460 +
1461 + el->sk[CLUSTER_LEN-1] = NULL;
1462 + } else {
1463 + /* Empty cluster */
1464 + memset(el->sk, 0, sizeof(el->sk));
1465 + }
1466 +
1467 + return(0);
1468 + }
1469 +
1470 + return(-1); /* Not found */
1471 +}
1472 +
1473 +/* ************************************* */
1474 +
1475 +static int remove_from_cluster(struct sock *sock,
1476 + struct ring_opt *pfr)
1477 +{
1478 + struct ring_cluster *el;
1479 +
1480 +#if defined(RING_DEBUG)
1481 + printk("--> remove_from_cluster(%d)\n", pfr->cluster_id);
1482 +#endif
1483 +
1484 + if(pfr->cluster_id == 0 /* 0 = No Cluster */)
1485 + return(0); /* Noting to do */
1486 +
1487 + el = ring_cluster_list;
1488 +
1489 + while(el != NULL) {
1490 + if(el->cluster_id == pfr->cluster_id) {
1491 + return(remove_from_cluster_list(el, sock));
1492 + } else
1493 + el = el->next;
1494 + }
1495 +
1496 + return(-EINVAL); /* Not found */
1497 +}
1498 +
1499 +/* ************************************* */
1500 +
1501 +static int add_to_cluster(struct sock *sock,
1502 + struct ring_opt *pfr,
1503 + u_short cluster_id)
1504 +{
1505 + struct ring_cluster *el;
1506 +
1507 +#ifndef RING_DEBUG
1508 + printk("--> add_to_cluster(%d)\n", cluster_id);
1509 +#endif
1510 +
1511 + if(cluster_id == 0 /* 0 = No Cluster */) return(-EINVAL);
1512 +
1513 + if(pfr->cluster_id != 0)
1514 + remove_from_cluster(sock, pfr);
1515 +
1516 + el = ring_cluster_list;
1517 +
1518 + while(el != NULL) {
1519 + if(el->cluster_id == cluster_id) {
1520 + return(add_to_cluster_list(el, sock));
1521 + } else
1522 + el = el->next;
1523 + }
1524 +
1525 + /* There's no existing cluster. We need to create one */
1526 + if((el = kmalloc(sizeof(struct ring_cluster), GFP_KERNEL)) == NULL)
1527 + return(-ENOMEM);
1528 +
1529 + el->cluster_id = cluster_id;
1530 + el->num_cluster_elements = 1;
1531 + el->hashing_mode = cluster_per_flow; /* Default */
1532 + el->hashing_id = 0;
1533 +
1534 + memset(el->sk, 0, sizeof(el->sk));
1535 + el->sk[0] = sock;
1536 + el->next = ring_cluster_list;
1537 + ring_cluster_list = el;
1538 + pfr->cluster_id = cluster_id;
1539 +
1540 + return(0); /* 0 = OK */
1541 +}
1542 +
1543 +/* ************************************* */
1544 +
1545 +/* Code taken/inspired from core/sock.c */
1546 +static int ring_setsockopt(struct socket *sock,
1547 + int level, int optname,
1548 + char *optval, int optlen)
1549 +{
1550 + struct ring_opt *pfr = ring_sk(sock->sk);
1551 + int val, found, ret = 0;
1552 + u_int cluster_id;
1553 + char devName[8];
1554 +
1555 + if((optlen<sizeof(int)) || (pfr == NULL))
1556 + return(-EINVAL);
1557 +
1558 + if (get_user(val, (int *)optval))
1559 + return -EFAULT;
1560 +
1561 + found = 1;
1562 +
1563 + switch(optname)
1564 + {
1565 + case SO_ATTACH_FILTER:
1566 + ret = -EINVAL;
1567 + if (optlen == sizeof(struct sock_fprog)) {
1568 + unsigned int fsize;
1569 + struct sock_fprog fprog;
1570 + struct sk_filter *filter;
1571 +
1572 + ret = -EFAULT;
1573 +
1574 + /*
1575 + NOTE
1576 +
1577 + Do not call copy_from_user within a held
1578 + splinlock (e.g. ring_mgmt_lock) as this caused
1579 + problems when certain debugging was enabled under
1580 + 2.6.5 -- including hard lockups of the machine.
1581 + */
1582 + if(copy_from_user(&fprog, optval, sizeof(fprog)))
1583 + break;
1584 +
1585 + fsize = sizeof(struct sock_filter) * fprog.len;
1586 + filter = kmalloc(fsize, GFP_KERNEL);
1587 +
1588 + if(filter == NULL) {
1589 + ret = -ENOMEM;
1590 + break;
1591 + }
1592 +
1593 + if(copy_from_user(filter->insns, fprog.filter, fsize))
1594 + break;
1595 +
1596 + filter->len = fprog.len;
1597 +
1598 + if(sk_chk_filter(filter->insns, filter->len) != 0) {
1599 + /* Bad filter specified */
1600 + kfree(filter);
1601 + pfr->bpfFilter = NULL;
1602 + break;
1603 + }
1604 +
1605 + /* get the lock, set the filter, release the lock */
1606 + write_lock(&ring_mgmt_lock);
1607 + pfr->bpfFilter = filter;
1608 + write_unlock(&ring_mgmt_lock);
1609 + }
1610 + ret = 0;
1611 + break;
1612 +
1613 + case SO_DETACH_FILTER:
1614 + write_lock(&ring_mgmt_lock);
1615 + found = 1;
1616 + if(pfr->bpfFilter != NULL) {
1617 + kfree(pfr->bpfFilter);
1618 + pfr->bpfFilter = NULL;
1619 + write_unlock(&ring_mgmt_lock);
1620 + break;
1621 + }
1622 + ret = -ENONET;
1623 + break;
1624 +
1625 + case SO_ADD_TO_CLUSTER:
1626 + if (optlen!=sizeof(val))
1627 + return -EINVAL;
1628 +
1629 + if (copy_from_user(&cluster_id, optval, sizeof(cluster_id)))
1630 + return -EFAULT;
1631 +
1632 + write_lock(&ring_mgmt_lock);
1633 + ret = add_to_cluster(sock->sk, pfr, cluster_id);
1634 + write_unlock(&ring_mgmt_lock);
1635 + break;
1636 +
1637 + case SO_REMOVE_FROM_CLUSTER:
1638 + write_lock(&ring_mgmt_lock);
1639 + ret = remove_from_cluster(sock->sk, pfr);
1640 + write_unlock(&ring_mgmt_lock);
1641 + break;
1642 +
1643 + case SO_SET_REFLECTOR:
1644 + if(optlen >= (sizeof(devName)-1))
1645 + return -EINVAL;
1646 +
1647 + if(optlen > 0) {
1648 + if(copy_from_user(devName, optval, optlen))
1649 + return -EFAULT;
1650 + }
1651 +
1652 + devName[optlen] = '\0';
1653 +
1654 +#if defined(RING_DEBUG)
1655 + printk("+++ SO_SET_REFLECTOR(%s)\n", devName);
1656 +#endif
1657 +
1658 + write_lock(&ring_mgmt_lock);
1659 + pfr->reflector_dev = dev_get_by_name(devName);
1660 + write_unlock(&ring_mgmt_lock);
1661 +
1662 +#if defined(RING_DEBUG)
1663 + if(pfr->reflector_dev != NULL)
1664 + printk("SO_SET_REFLECTOR(%s): succeded\n", devName);
1665 + else
1666 + printk("SO_SET_REFLECTOR(%s): device unknown\n", devName);
1667 +#endif
1668 + break;
1669 +
1670 + default:
1671 + found = 0;
1672 + break;
1673 + }
1674 +
1675 + if(found)
1676 + return(ret);
1677 + else
1678 + return(sock_setsockopt(sock, level, optname, optval, optlen));
1679 +}
1680 +
1681 +/* ************************************* */
1682 +
1683 +static int ring_ioctl(struct socket *sock,
1684 + unsigned int cmd, unsigned long arg)
1685 +{
1686 + switch(cmd)
1687 + {
1688 + case SIOCGIFFLAGS:
1689 + case SIOCSIFFLAGS:
1690 + case SIOCGIFCONF:
1691 + case SIOCGIFMETRIC:
1692 + case SIOCSIFMETRIC:
1693 + case SIOCGIFMEM:
1694 + case SIOCSIFMEM:
1695 + case SIOCGIFMTU:
1696 + case SIOCSIFMTU:
1697 + case SIOCSIFLINK:
1698 + case SIOCGIFHWADDR:
1699 + case SIOCSIFHWADDR:
1700 + case SIOCSIFMAP:
1701 + case SIOCGIFMAP:
1702 + case SIOCSIFSLAVE:
1703 + case SIOCGIFSLAVE:
1704 + case SIOCGIFINDEX:
1705 + case SIOCGIFNAME:
1706 + case SIOCGIFCOUNT:
1707 + case SIOCSIFHWBROADCAST:
1708 + return(dev_ioctl(cmd,(void *) arg));
1709 +
1710 + default:
1711 + return -EOPNOTSUPP;
1712 + }
1713 +
1714 + return 0;
1715 +}
1716 +
1717 +/* ************************************* */
1718 +
1719 +static struct proto_ops ring_ops = {
1720 + .family = PF_RING,
1721 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
1722 + .owner = THIS_MODULE,
1723 +#endif
1724 +
1725 + /* Operations that make no sense on ring sockets. */
1726 + .connect = sock_no_connect,
1727 + .socketpair = sock_no_socketpair,
1728 + .accept = sock_no_accept,
1729 + .getname = sock_no_getname,
1730 + .listen = sock_no_listen,
1731 + .shutdown = sock_no_shutdown,
1732 + .sendpage = sock_no_sendpage,
1733 + .sendmsg = sock_no_sendmsg,
1734 + .getsockopt = sock_no_getsockopt,
1735 +
1736 + /* Now the operations that really occur. */
1737 + .release = ring_release,
1738 + .bind = ring_bind,
1739 + .mmap = ring_mmap,
1740 + .poll = ring_poll,
1741 + .setsockopt = ring_setsockopt,
1742 + .ioctl = ring_ioctl,
1743 + .recvmsg = ring_recvmsg,
1744 +};
1745 +
1746 +/* ************************************ */
1747 +
1748 +static struct net_proto_family ring_family_ops = {
1749 + .family = PF_RING,
1750 + .create = ring_create,
1751 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
1752 + .owner = THIS_MODULE,
1753 +#endif
1754 +};
1755 +
1756 +// BD: API changed in 2.6.12, ref:
1757 +// http://svn.clkao.org/svnweb/linux/revision/?rev=28201
1758 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,11))
1759 +static struct proto ring_proto = {
1760 + .name = "PF_RING",
1761 + .owner = THIS_MODULE,
1762 + .obj_size = sizeof(struct sock),
1763 +};
1764 +#endif
1765 +
1766 +/* ************************************ */
1767 +
1768 +static void __exit ring_exit(void)
1769 +{
1770 + struct list_head *ptr;
1771 + struct ring_element *entry;
1772 +
1773 + for(ptr = ring_table.next; ptr != &ring_table; ptr = ptr->next) {
1774 + entry = list_entry(ptr, struct ring_element, list);
1775 + kfree(entry);
1776 + }
1777 +
1778 + while(ring_cluster_list != NULL) {
1779 + struct ring_cluster *next = ring_cluster_list->next;
1780 + kfree(ring_cluster_list);
1781 + ring_cluster_list = next;
1782 + }
1783 +
1784 + set_skb_ring_handler(NULL);
1785 + set_buffer_ring_handler(NULL);
1786 + sock_unregister(PF_RING);
1787 +
1788 + printk("PF_RING shut down.\n");
1789 +}
1790 +
1791 +/* ************************************ */
1792 +
1793 +static int __init ring_init(void)
1794 +{
1795 + printk("Welcome to PF_RING %s\n(C) 2004-05 L.Deri <deri@ntop.org>\n",
1796 + RING_VERSION);
1797 +
1798 + INIT_LIST_HEAD(&ring_table);
1799 + ring_cluster_list = NULL;
1800 +
1801 + sock_register(&ring_family_ops);
1802 +
1803 + set_skb_ring_handler(skb_ring_handler);
1804 + set_buffer_ring_handler(buffer_ring_handler);
1805 +
1806 + if(get_buffer_ring_handler() != buffer_ring_handler) {
1807 + printk("PF_RING: set_buffer_ring_handler FAILED\n");
1808 +
1809 + set_skb_ring_handler(NULL);
1810 + set_buffer_ring_handler(NULL);
1811 + sock_unregister(PF_RING);
1812 + return -1;
1813 + } else {
1814 + printk("PF_RING: bucket length %d bytes\n", bucket_len);
1815 + printk("PF_RING: ring slots %d\n", num_slots);
1816 + printk("PF_RING: sample rate %d [1=no sampling]\n", sample_rate);
1817 + printk("PF_RING: capture TX %s\n",
1818 + enable_tx_capture ? "Yes [RX+TX]" : "No [RX only]");
1819 + printk("PF_RING: transparent mode %s\n",
1820 + transparent_mode ? "Yes" : "No");
1821 +
1822 + printk("PF_RING initialized correctly.\n");
1823 + return 0;
1824 + }
1825 +}
1826 +
1827 +module_init(ring_init);
1828 +module_exit(ring_exit);
1829 +MODULE_LICENSE("GPL");
1830 +
1831 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
1832 +MODULE_ALIAS_NETPROTO(PF_RING);
1833 +#endif
Personal OpenWRT clone
This page took 0.127462 seconds and 5 git commands to generate.