URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [core/] [profile.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


#include <linux/config.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/netdevice.h>
#include <linux/string.h>
#include <linux/skbuff.h>
#include <linux/proc_fs.h>
#include <linux/init.h>
#include <linux/ip.h>
#include <linux/inet.h>
#include <net/checksum.h>
 
#include <asm/processor.h>
#include <asm/uaccess.h>
#include <asm/system.h>
 
#include <net/profile.h>
 
#ifdef CONFIG_NET_PROFILE
 
atomic_t net_profile_active;
struct timeval net_profile_adjust;
 
NET_PROFILE_DEFINE(total);
 
struct net_profile_slot *net_profile_chain = &net_prof_total;
 
#ifdef __alpha__
__u32 alpha_lo;
long alpha_hi;
 
static void alpha_tick(unsigned long);
 
static struct timer_list alpha_timer =
        { NULL, NULL, 0, 0L, alpha_tick };
 
void alpha_tick(unsigned long dummy)
{
        struct timeval dummy_stamp;
        net_profile_stamp(&dummy_stamp);
        alpha_timer.expires = jiffies + 4*HZ;
        add_timer(&alpha_timer);
}
 
#endif
 
void net_profile_irq_adjust(struct timeval *entered, struct timeval* leaved)
{
        struct net_profile_slot *s;
 
        net_profile_sub(entered, leaved);
        for (s = net_profile_chain; s; s = s->next) {
                if (s->active)
                        net_profile_add(leaved, &s->irq);
        }
}
 
 
#ifdef CONFIG_PROC_FS
static int profile_read_proc(char *buffer, char **start, off_t offset,
                             int length, int *eof, void *data)
{
        off_t pos=0;
        off_t begin=0;
        int len=0;
        struct net_profile_slot *s;
 
        len+= sprintf(buffer, "Slot            Hits       Hi         Lo         OnIrqHi    OnIrqLo    Ufl\n");
 
        if (offset == 0) {
                cli();
                net_prof_total.active = 1;
                atomic_inc(&net_profile_active);
                NET_PROFILE_LEAVE(total);
                sti();
        }
        for (s = net_profile_chain; s; s = s->next) {
                struct net_profile_slot tmp;
 
                cli();
                tmp = *s;
 
                /* Wrong, but pretty close to truth */
 
                s->accumulator.tv_sec = 0;
                s->accumulator.tv_usec = 0;
                s->irq.tv_sec = 0;
                s->irq.tv_usec = 0;
                s->hits = 0;
                s->underflow = 0;
                /* Repair active count, it is possible, only if code has a bug */
                if (s->active) {
                        s->active = 0;
                        atomic_dec(&net_profile_active);
                }
                sti();
 
                net_profile_sub(&tmp.irq, &tmp.accumulator);
 
                len += sprintf(buffer+len,"%-15s %-10d %-10ld %-10lu %-10lu %-10lu %d/%d",
                               tmp.id,
                               tmp.hits,
                               tmp.accumulator.tv_sec,
                               tmp.accumulator.tv_usec,
                               tmp.irq.tv_sec,
                               tmp.irq.tv_usec,
                               tmp.underflow, tmp.active);
 
                        buffer[len++]='\n';
 
                        pos=begin+len;
                        if(pos<offset) {
                                len=0;
                                begin=pos;
                        }
                        if(pos>offset+length)
                                goto done;
        }
        *eof = 1;
 
done:
        *start=buffer+(offset-begin);
        len-=(offset-begin);
        if(len>length)
                len=length;
        if (len < 0)
                len = 0;
        if (offset == 0) {
                cli();
                net_prof_total.active = 0;
                net_prof_total.hits = 0;
                net_profile_stamp(&net_prof_total.entered);
                sti();
        }
        return len;
}
#endif
 
struct iphdr whitehole_iph;
int whitehole_count;
 
static int whitehole_xmit(struct sk_buff *skb, struct net_device *dev)
{
        struct net_device_stats *stats;
 
        stats = (struct net_device_stats *)dev->priv;
        stats->tx_packets++;
        stats->tx_bytes+=skb->len;
 
        dev_kfree_skb(skb);
        return 0;
}
 
static void whitehole_inject(unsigned long);
int whitehole_init(struct net_device *dev);
 
static struct timer_list whitehole_timer =
        { NULL, NULL, 0, 0L, whitehole_inject };
 
static struct net_device whitehole_dev = {
        "whitehole", 0x0, 0x0, 0x0, 0x0, 0, 0, 0, 0, 0, NULL, whitehole_init, };
 
static int whitehole_open(struct net_device *dev)
{
        whitehole_count = 100000;
        whitehole_timer.expires = jiffies + 5*HZ;
        add_timer(&whitehole_timer);
        return 0;
}
 
static int whitehole_close(struct net_device *dev)
{
        del_timer(&whitehole_timer);
        return 0;
}
 
static void whitehole_inject(unsigned long dummy)
{
        struct net_device_stats *stats = (struct net_device_stats *)whitehole_dev.priv;
        extern int netdev_dropping;
 
        do {
                struct iphdr *iph;
                struct sk_buff *skb = alloc_skb(128, GFP_ATOMIC);
                if (!skb)
                        break;
                skb_reserve(skb, 32);
                iph = (struct iphdr*)skb_put(skb, sizeof(*iph));
                skb->mac.raw = ((u8*)iph) - 14;
                memcpy(iph, &whitehole_iph, sizeof(*iph));
                skb->protocol = __constant_htons(ETH_P_IP);
                skb->dev = &whitehole_dev;
                skb->pkt_type = PACKET_HOST;
                stats->rx_packets++;
                stats->rx_bytes += skb->len;
                netif_rx(skb);
                whitehole_count--;
        } while (netdev_dropping == 0 && whitehole_count>0);
        if (whitehole_count > 0) {
                whitehole_timer.expires = jiffies + 1;
                add_timer(&whitehole_timer);
        }
}
 
static struct net_device_stats *whitehole_get_stats(struct net_device *dev)
{
        struct net_device_stats *stats = (struct net_device_stats *) dev->priv;
        return stats;
}
 
int __init whitehole_init(struct net_device *dev)
{
        dev->priv = kmalloc(sizeof(struct net_device_stats), GFP_KERNEL);
        if (dev->priv == NULL)
                return -ENOBUFS;
        memset(dev->priv, 0, sizeof(struct net_device_stats));
        dev->get_stats  = whitehole_get_stats;
        dev->hard_start_xmit = whitehole_xmit;
        dev->open = whitehole_open;
        dev->stop = whitehole_close;
        ether_setup(dev);
        dev->tx_queue_len = 0;
        dev->flags |= IFF_NOARP;
        dev->flags &= ~(IFF_BROADCAST|IFF_MULTICAST);
        dev->iflink = 0;
        whitehole_iph.ihl = 5;
        whitehole_iph.version = 4;
        whitehole_iph.ttl = 2;
        whitehole_iph.saddr = in_aton("193.233.7.21");
        whitehole_iph.daddr = in_aton("193.233.7.10");
        whitehole_iph.tot_len = htons(20);
        whitehole_iph.check = ip_compute_csum((void *)&whitehole_iph, 20);
        return 0;
}
 
int net_profile_register(struct net_profile_slot *slot)
{
        cli();
        slot->next = net_profile_chain;
        net_profile_chain = slot;
        sti();
        return 0;
}
 
int net_profile_unregister(struct net_profile_slot *slot)
{
        struct net_profile_slot **sp, *s;
 
        for (sp = &net_profile_chain; (s = *sp) != NULL; sp = &s->next) {
                if (s == slot) {
                        cli();
                        *sp = s->next;
                        sti();
                        return 0;
                }
        }
        return -ESRCH;
}
 
 
int __init net_profile_init(void)
{
        int i;
 
#ifdef CONFIG_PROC_FS
        create_proc_read_entry("net/profile", 0, 0, profile_read_proc, NULL);
#endif
 
        register_netdevice(&whitehole_dev);
 
        printk("Evaluating net profiler cost ...");
#ifdef __alpha__
        alpha_tick(0);
#endif
        for (i=0; i<1024; i++) {
                NET_PROFILE_ENTER(total);
                NET_PROFILE_LEAVE(total);
        }
        if (net_prof_total.accumulator.tv_sec) {
                printk(" too high!\n");
        } else {
                net_profile_adjust.tv_usec = net_prof_total.accumulator.tv_usec>>10;
                printk("%ld units\n", net_profile_adjust.tv_usec);
        }
        net_prof_total.hits = 0;
        net_profile_stamp(&net_prof_total.entered);
        return 0;
}
 
#endif

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [core/] [profile.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1278	phoenix	`#include <linux/config.h>`
2			`#include <linux/types.h>`
3			`#include <linux/kernel.h>`
4			`#include <linux/sched.h>`
5			`#include <linux/mm.h>`
6			`#include <linux/interrupt.h>`
7			`#include <linux/netdevice.h>`
8			`#include <linux/string.h>`
9			`#include <linux/skbuff.h>`
10			`#include <linux/proc_fs.h>`
11			`#include <linux/init.h>`
12			`#include <linux/ip.h>`
13			`#include <linux/inet.h>`
14			`#include <net/checksum.h>`
15
16			`#include <asm/processor.h>`
17			`#include <asm/uaccess.h>`
18			`#include <asm/system.h>`
19
20			`#include <net/profile.h>`
21
22			`#ifdef CONFIG_NET_PROFILE`
23
24			`atomic_t net_profile_active;`
25			`struct timeval net_profile_adjust;`
26
27			`NET_PROFILE_DEFINE(total);`
28
29			`struct net_profile_slot *net_profile_chain = &net_prof_total;`
30
31			`#ifdef __alpha__`
32			`__u32 alpha_lo;`
33			`long alpha_hi;`
34
35			`static void alpha_tick(unsigned long);`
36
37			`static struct timer_list alpha_timer =`
38			`{ NULL, NULL, 0, 0L, alpha_tick };`
39
40			`void alpha_tick(unsigned long dummy)`
41			`{`
42			`struct timeval dummy_stamp;`
43			`net_profile_stamp(&dummy_stamp);`
44			`alpha_timer.expires = jiffies + 4*HZ;`
45			`add_timer(&alpha_timer);`
46			`}`
47
48			`#endif`
49
50			`void net_profile_irq_adjust(struct timeval entered, struct timeval leaved)`
51			`{`
52			`struct net_profile_slot *s;`
53
54			`net_profile_sub(entered, leaved);`
55			`for (s = net_profile_chain; s; s = s->next) {`
56			`if (s->active)`
57			`net_profile_add(leaved, &s->irq);`
58			`}`
59			`}`
60
61
62			`#ifdef CONFIG_PROC_FS`
63			`static int profile_read_proc(char buffer, char *start, off_t offset,`
64			`int length, int eof, void data)`
65			`{`
66			`off_t pos=0;`
67			`off_t begin=0;`
68			`int len=0;`
69			`struct net_profile_slot *s;`
70
71			`len+= sprintf(buffer, "Slot Hits Hi Lo OnIrqHi OnIrqLo Ufl\n");`
72
73			`if (offset == 0) {`
74			`cli();`
75			`net_prof_total.active = 1;`
76			`atomic_inc(&net_profile_active);`
77			`NET_PROFILE_LEAVE(total);`
78			`sti();`
79			`}`
80			`for (s = net_profile_chain; s; s = s->next) {`
81			`struct net_profile_slot tmp;`
82
83			`cli();`
84			`tmp = *s;`
85
86			`/* Wrong, but pretty close to truth */`
87
88			`s->accumulator.tv_sec = 0;`
89			`s->accumulator.tv_usec = 0;`
90			`s->irq.tv_sec = 0;`
91			`s->irq.tv_usec = 0;`
92			`s->hits = 0;`
93			`s->underflow = 0;`
94			`/* Repair active count, it is possible, only if code has a bug */`
95			`if (s->active) {`
96			`s->active = 0;`
97			`atomic_dec(&net_profile_active);`
98			`}`
99			`sti();`
100
101			`net_profile_sub(&tmp.irq, &tmp.accumulator);`
102
103			`len += sprintf(buffer+len,"%-15s %-10d %-10ld %-10lu %-10lu %-10lu %d/%d",`
104			`tmp.id,`
105			`tmp.hits,`
106			`tmp.accumulator.tv_sec,`
107			`tmp.accumulator.tv_usec,`
108			`tmp.irq.tv_sec,`
109			`tmp.irq.tv_usec,`
110			`tmp.underflow, tmp.active);`
111
112			`buffer[len++]='\n';`
113
114			`pos=begin+len;`
115			`if(pos<offset) {`
116			`len=0;`
117			`begin=pos;`
118			`}`
119			`if(pos>offset+length)`
120			`goto done;`
121			`}`
122			`*eof = 1;`
123
124			`done:`
125			`*start=buffer+(offset-begin);`
126			`len-=(offset-begin);`
127			`if(len>length)`
128			`len=length;`
129			`if (len < 0)`
130			`len = 0;`
131			`if (offset == 0) {`
132			`cli();`
133			`net_prof_total.active = 0;`
134			`net_prof_total.hits = 0;`
135			`net_profile_stamp(&net_prof_total.entered);`
136			`sti();`
137			`}`
138			`return len;`
139			`}`
140			`#endif`
141
142			`struct iphdr whitehole_iph;`
143			`int whitehole_count;`
144
145			`static int whitehole_xmit(struct sk_buff skb, struct net_device dev)`
146			`{`
147			`struct net_device_stats *stats;`
148
149			`stats = (struct net_device_stats *)dev->priv;`
150			`stats->tx_packets++;`
151			`stats->tx_bytes+=skb->len;`
152
153			`dev_kfree_skb(skb);`
154			`return 0;`
155			`}`
156
157			`static void whitehole_inject(unsigned long);`
158			`int whitehole_init(struct net_device *dev);`
159
160			`static struct timer_list whitehole_timer =`
161			`{ NULL, NULL, 0, 0L, whitehole_inject };`
162
163			`static struct net_device whitehole_dev = {`
164			`"whitehole", 0x0, 0x0, 0x0, 0x0, 0, 0, 0, 0, 0, NULL, whitehole_init, };`
165
166			`static int whitehole_open(struct net_device *dev)`
167			`{`
168			`whitehole_count = 100000;`
169			`whitehole_timer.expires = jiffies + 5*HZ;`
170			`add_timer(&whitehole_timer);`
171			`return 0;`
172			`}`
173
174			`static int whitehole_close(struct net_device *dev)`
175			`{`
176			`del_timer(&whitehole_timer);`
177			`return 0;`
178			`}`
179
180			`static void whitehole_inject(unsigned long dummy)`
181			`{`
182			`struct net_device_stats stats = (struct net_device_stats )whitehole_dev.priv;`
183			`extern int netdev_dropping;`
184
185			`do {`
186			`struct iphdr *iph;`
187			`struct sk_buff *skb = alloc_skb(128, GFP_ATOMIC);`
188			`if (!skb)`
189			`break;`
190			`skb_reserve(skb, 32);`
191			`iph = (struct iphdr)skb_put(skb, sizeof(iph));`
192			`skb->mac.raw = ((u8*)iph) - 14;`
193			`memcpy(iph, &whitehole_iph, sizeof(*iph));`
194			`skb->protocol = __constant_htons(ETH_P_IP);`
195			`skb->dev = &whitehole_dev;`
196			`skb->pkt_type = PACKET_HOST;`
197			`stats->rx_packets++;`
198			`stats->rx_bytes += skb->len;`
199			`netif_rx(skb);`
200			`whitehole_count--;`
201			`} while (netdev_dropping == 0 && whitehole_count>0);`
202			`if (whitehole_count > 0) {`
203			`whitehole_timer.expires = jiffies + 1;`
204			`add_timer(&whitehole_timer);`
205			`}`
206			`}`
207
208			`static struct net_device_stats whitehole_get_stats(struct net_device dev)`
209			`{`
210			`struct net_device_stats stats = (struct net_device_stats ) dev->priv;`
211			`return stats;`
212			`}`
213
214			`int __init whitehole_init(struct net_device *dev)`
215			`{`
216			`dev->priv = kmalloc(sizeof(struct net_device_stats), GFP_KERNEL);`
217			`if (dev->priv == NULL)`
218			`return -ENOBUFS;`
219			`memset(dev->priv, 0, sizeof(struct net_device_stats));`
220			`dev->get_stats = whitehole_get_stats;`
221			`dev->hard_start_xmit = whitehole_xmit;`
222			`dev->open = whitehole_open;`
223			`dev->stop = whitehole_close;`
224			`ether_setup(dev);`
225			`dev->tx_queue_len = 0;`
226			`dev->flags \|= IFF_NOARP;`
227			`dev->flags &= ~(IFF_BROADCAST\|IFF_MULTICAST);`
228			`dev->iflink = 0;`
229			`whitehole_iph.ihl = 5;`
230			`whitehole_iph.version = 4;`
231			`whitehole_iph.ttl = 2;`
232			`whitehole_iph.saddr = in_aton("193.233.7.21");`
233			`whitehole_iph.daddr = in_aton("193.233.7.10");`
234			`whitehole_iph.tot_len = htons(20);`
235			`whitehole_iph.check = ip_compute_csum((void *)&whitehole_iph, 20);`
236			`return 0;`
237			`}`
238
239			`int net_profile_register(struct net_profile_slot *slot)`
240			`{`
241			`cli();`
242			`slot->next = net_profile_chain;`
243			`net_profile_chain = slot;`
244			`sti();`
245			`return 0;`
246			`}`
247
248			`int net_profile_unregister(struct net_profile_slot *slot)`
249			`{`
250			`struct net_profile_slot *sp, s;`
251
252			`for (sp = &net_profile_chain; (s = *sp) != NULL; sp = &s->next) {`
253			`if (s == slot) {`
254			`cli();`
255			`*sp = s->next;`
256			`sti();`
257			`return 0;`
258			`}`
259			`}`
260			`return -ESRCH;`
261			`}`
262
263
264			`int __init net_profile_init(void)`
265			`{`
266			`int i;`
267
268			`#ifdef CONFIG_PROC_FS`
269			`create_proc_read_entry("net/profile", 0, 0, profile_read_proc, NULL);`
270			`#endif`
271
272			`register_netdevice(&whitehole_dev);`
273
274			`printk("Evaluating net profiler cost ...");`
275			`#ifdef __alpha__`
276			`alpha_tick(0);`
277			`#endif`
278			`for (i=0; i<1024; i++) {`
279			`NET_PROFILE_ENTER(total);`
280			`NET_PROFILE_LEAVE(total);`
281			`}`
282			`if (net_prof_total.accumulator.tv_sec) {`
283			`printk(" too high!\n");`
284			`} else {`
285			`net_profile_adjust.tv_usec = net_prof_total.accumulator.tv_usec>>10;`
286			`printk("%ld units\n", net_profile_adjust.tv_usec);`
287			`}`
288			`net_prof_total.hits = 0;`
289			`net_profile_stamp(&net_prof_total.entered);`
290			`return 0;`
291			`}`
292
293			`#endif`