kk Blog —— 通用基础


date [-d @int|str] [+%s|"+%F %T"]
netstat -ltunp
sar -n DEV 1

Netfilter HOOK

下图是Netfilter的IPV4下的结构

可以看到这是基于早期版本内核的,如今内核挂载点的宏定义发生了变化,从NF_IP_XXX => NF_INET_XXX

每个注册的钩子函数经过处理后都将返回下列值之一,告知Netfilter核心代码处理结果,以便对报文采取相应的动作:
NF_ACCEPT:继续正常的报文处理;
NF_DROP:将报文丢弃;
NF_STOLEN:由钩子函数处理了该报文,不要再继续传送;
NF_QUEUE:将报文入队,通常交由用户程序处理;
NF_REPEAT:再次调用该钩子函数。

// code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/net.h>
#include <net/tcp.h>
#include <linux/skbuff.h>
#include <linux/netfilter.h>
#include <linux/netfilter_ipv4.h>
#include <net/ip_vs.h>
#include <net/sock.h>
#include <linux/gfp.h>
#include <linux/kallsyms.h>
#include <linux/version.h>

static unsigned int test_runit(unsigned int hooknum,
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 32)
		truct sk_buff **skb,
#else
		struct sk_buff *skb,
#endif
		const struct net_device *in,
		const struct net_device *out,
		int (*okfn)(struct sk_buff *))
{
	...
	return NF_ACCEPT;
}

static struct nf_hook_ops hook_test = {
	.hook    = test_runit,
	.owner    = THIS_MODULE,
	.pf    = PF_INET,
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 32)
	.hooknum        = NF_IP_LOCAL_OUT,
#else
	.hooknum        = NF_INET_LOCAL_OUT,
#endif
	.priority       = 100,
};

static int  __init test_start_init(void)
{
	printk("Hi test pre\n");
	nf_register_hook(&hook_test);
	return 0;
}

static void __exit test_start_exit(void)
{
	nf_unregister_hook(&hook_test);
	printk("Bye test pre\n");
}
module_init(test_start_init);
module_exit(test_start_exit);
MODULE_LICENSE("GPL");

数据交换sysctl + 定时器(code)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/types.h>

#include <linux/sysctl.h>
#include <linux/timer.h>

int value;

static struct ctl_table debug_table[] = {
	{
		.ctl_name       = CTL_UNNUMBERED,
		.procname       = "value",
		.data           = &value,
		.maxlen         = sizeof(value),
		.mode           = 0644,
		.proc_handler   = &proc_dointvec, },
	{ },
};

static struct ctl_table ws_dir_table[] = {
	{
		.ctl_name       = CTL_UNNUMBERED,
		.procname        = "debug",
		.mode            = 0555,
		.child           = debug_table, },
	{ },
};

static struct ctl_table ipv4_dir_table[] = {
	{
		.ctl_name       = NET_IPV4,
		.procname    = "ipv4",
		.mode        = 0555,
		.child       = ws_dir_table, },
	{ },
};

static ctl_table net_dir_table[] = {
	{
		.ctl_name       = CTL_NET,
		.procname    = "net",
		.mode        = 0555,
		.child           = ipv4_dir_table, },
	{ },
};

struct timer_list timer_last_stat;
static void output_value(unsigned long data)
{
	printk("value = %d\n", value);
	mod_timer(&timer_last_stat, jiffies+HZ*5);
}

struct ctl_table_header *ctl_header = NULL;
static int __init file_test_init(void)
{
	printk("sysctl test init\n");
	value = 111;
	ctl_header= register_sysctl_table (net_dir_table, 0);
	if(!ctl_header){
		printk(KERN_ERR"SYNPROXY: sp_sysctl_init() calls failed.");
		return -1;
	}
	setup_timer(&timer_last_stat, output_value, 0);
	mod_timer(&timer_last_stat, jiffies+HZ*5);
	return 0;
}

static void __exit file_test_exit(void)
{
	if (ctl_header)
		unregister_sysctl_table(ctl_header);
	del_timer(&timer_last_stat);
	printk("sysctl test exit\n");
}

module_init(file_test_init);
module_exit(file_test_exit);

MODULE_LICENSE("GPL");

1
2
3
4
5
6
7
8
$ dmesg
...
value = 111
$ echo 123 > /proc/sys/net/ipv4/debug/value
$ dmesg
...
value = 111
value = 123

内核定时器的使用

LINUX内核定时器是内核用来控制在未来某个时间点(基于jiffies)调度执行某个函数的一种机制,其实现位于 <linux/timer.h> 和 kernel/timer.c 文件中。

被调度的函数肯定是异步执行的,它类似于一种“软件中断”,而且是处于非进程的上下文中,所以调度函数必须遵守以下规则:
1. 没有 current 指针、不允许访问用户空间。因为没有进程上下文,相关代码和被中断的进程没有任何联系。
2. 不能执行休眠(或可能引起休眠的函数)和调度。
3. 任何被访问的数据结构都应该针对并发访问进行保护,以防止竞争条件。

内核定时器的调度函数运行过一次后就不会再被运行了(相当于自动注销),但可以通过在被调度的函数中重新调度自己来周期运行。

在SMP系统中,调度函数总是在注册它的同一CPU上运行,以尽可能获得缓存的局域性。

定时器API

内核定时器的数据结构

1
2
3
4
5
6
7
8
9
10
struct timer_list {
  struct list_head entry;
 
  unsigned long expires;
  void (*function)(unsigned long);
  unsigned long data;
 
  struct tvec_base *base;
  /* ... */
};

其中 expires 字段表示期望定时器执行的 jiffies 值,到达该 jiffies 值时,将调用 function 函数,并传递 data 作为参数。当一个定时器被注册到内核之后,entry 字段用来连接该定时器到一个内核链表中。base 字段是内核内部实现所用的。 需要注意的是 expires 的值是32位的,因为内核定时器并不适用于长的未来时间点。

初始化

在使用 struct timer_list 之前,需要初始化该数据结构,确保所有的字段都被正确地设置。初始化有两种方法。

方法一:
1
DEFINE_TIMER(timer_name, function_name, expires_value, data);

该宏会静态创建一个名叫 timer_name 内核定时器,并初始化其 function, expires, name 和 base 字段。

方法二:
1
2
3
struct timer_list mytimer;
setup_timer(&mytimer, (*function)(unsigned long), unsigned long data);
mytimer.expires = jiffies + 5*HZ;
方法三:
1
2
3
4
5
struct timer_list mytimer;
init_timer(&mytimer);
  mytimer ->timer.expires = jiffies + 5*HZ;
  mytimer ->timer.data = (unsigned long) dev;
  mytimer ->timer.function = &corkscrew_timer; /* timer handler */

通过init_timer()动态地定义一个定时器,此后,将处理函数的地址和参数绑定给一个timer_list,
注意,无论用哪种方法初始化,其本质都只是给字段赋值,所以只要在运行 add_timer() 之前,expires, function 和 data 字段都可以直接再修改。
关于上面这些宏和函数的定义,参见 include/linux/timer.h。

注册

定时器要生效,还必须被连接到内核专门的链表中,这可以通过 add_timer(struct timer_list *timer) 来实现。

重新注册

要修改一个定时器的调度时间,可以通过调用 mod_timer(struct timer_list *timer, unsigned long expires)。mod_timer() 会重新注册定时器到内核,而不管定时器函数是否被运行过。

注销

注销一个定时器,可以通过 del_timer(struct timer_list timer) 或 del_timer_sync(struct timer_list timer)。其中 del_timer_sync 是用在 SMP 系统上的(在非SMP系统上,它等于del_timer),当要被注销的定时器函数正在另一个 cpu 上运行时,del_timer_sync() 会等待其运行完,所以这个函数会休眠。另外还应避免它和被调度的函数争用同一个锁。对于一个已经被运行过且没有重新注册自己的定时器而言,注销函数其实也 没什么事可做。

1
int timer_pending(const struct timer_list *timer)

这个函数用来判断一个定时器是否被添加到了内核链表中以等待被调度运行。注意,当一个定时器函数即将要被运行前,内核会把相应的定时器从内核链表中删除(相当于注销)

例子1:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <linux/module.h>
#include <linux/timer.h>
#include <linux/jiffies.h>
 
struct timer_list mytimer;
static void myfunc(unsigned long data)
{
	printk("%s/n", (char *)data);
	mod_timer(&mytimer, jiffies + 2*HZ);
}
 
static int __init mytimer_init(void)
{
	setup_timer(&mytimer, myfunc, (unsigned long)"Hello, world!");
	mytimer.expires = jiffies + HZ;
	add_timer(&mytimer);
	return 0;
}
 
static void __exit mytimer_exit(void)
{
	del_timer(&mytimer);
}
module_init(mytimer_init);
module_exit(mytimer_exit);
例子2:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
static struct timer_list power_button_poll_timer;
static void power_button_poll(unsigned long dummy)
{
	if (gpio_line_get(N2100_POWER_BUTTON) == 0) {
		ctrl_alt_del();
		return;
	}
	power_button_poll_timer.expires = jiffies + (HZ / 10);
	add_timer(&power_button_poll_timer);
}
static void __init n2100_init_machine(void)
{
...
	init_timer(&power_button_poll_timer);
	power_button_poll_timer.function = power_button_poll;
	power_button_poll_timer.expires = jiffies + (HZ / 10);
	add_timer(&power_button_poll_timer);
}
例子3:

设备open时初始化和注册定时器

1
2
3
4
5
6
7
8
9
10
static int corkscrew_open(struct net_device *dev)
{
...
	  init_timer(&vp->timer);    
	  vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
	  vp->timer.data = (unsigned long) dev;
	  vp->timer.function = &corkscrew_timer; /* timer handler */
	  add_timer(&vp->timer);
...
}

定时器超时处理函数,对定时器的超时时间重新赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
static void corkscrew_timer(unsigned long data)
{
...
	vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
	add_timer(&vp->timer);
...
}
 
设备close时删除定时器
static int corkscrew_close(struct net_device *dev)
{
...
	del_timer(&vp->timer);
...
}
例子4:

本例子用DEFINE_TIMER静态创建定时器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <linux/module.h>
#include <linux/jiffies.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/timer.h>
#include <linux/leds.h>
static void ledtrig_ide_timerfunc(unsigned long data);
DEFINE_LED_TRIGGER(ledtrig_ide);
static DEFINE_TIMER(ledtrig_ide_timer, ledtrig_ide_timerfunc, 0, 0);
static int ide_activity;
static int ide_lastactivity;
void ledtrig_ide_activity(void)
{
	ide_activity++;
	if (!timer_pending(&ledtrig_ide_timer))
		mod_timer(&ledtrig_ide_timer, jiffies + msecs_to_jiffies(10));
}
EXPORT_SYMBOL(ledtrig_ide_activity);
static void ledtrig_ide_timerfunc(unsigned long data)
{
	if (ide_lastactivity != ide_activity) {
		ide_lastactivity = ide_activity;
		led_trigger_event(ledtrig_ide, LED_FULL);
		mod_timer(&ledtrig_ide_timer, jiffies + msecs_to_jiffies(10));
	} else {
		led_trigger_event(ledtrig_ide, LED_OFF);
	}
}
static int __init ledtrig_ide_init(void)
{
	led_trigger_register_simple("ide-disk", &ledtrig_ide);
	return 0;
}
static void __exit ledtrig_ide_exit(void)
{
	led_trigger_unregister_simple(ledtrig_ide);
}
module_init(ledtrig_ide_init);
module_exit(ledtrig_ide_exit);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
add_timer() -- 将定时器添加到定时器等待队列中
用add_timer()函数来看timer_base的作用
static inline void add_timer(struct timer_list *timer)
{
	BUG_ON(timer_pending(timer));
	__mod_timer(timer, timer->expires);
}

int __mod_timer(struct timer_list *timer, unsigned long expires)
{
	tvec_base_t *base, *new_base;
	unsigned long flags;
	int ret = 0;
	timer_stats_timer_set_start_info(timer);
	BUG_ON(!timer->function);
	base = lock_timer_base(timer, &flags);
如果timer已经放到定时链表中,则释放开
|--------------------------------|
|   if (timer_pending(timer)) { -|
|       detach_timer(timer, 0); -|
|       ret = 1;                 |
|   }                            |
|--------------------------------|
获取当前CPU的timer base
|-----------------------------------------|
|   new_base = __get_cpu_var(tvec_bases); |
|-----------------------------------------|
如果当前CPU的timer base不是当前timer中的base, 更新timer的base
|----------------------------------------------------|
|   if (base != new_base) {                          |
|       if (likely(base->running_timer != timer)) { -|
|           timer->base = NULL;                      |
|           spin_unlock(&base->lock);                |
|           base = new_base;                         |
|           spin_lock(&base->lock);                  |
|           timer->base = base;                      |
|       }                                            |
|   }                                                |
|----------------------------------------------------|
给定时器timer设置超时时间;并添加该时钟
|-------------------------------------|
|   timer->expires = expires;         |
|   internal_add_timer(base, timer); -|
|-------------------------------------|
	spin_unlock_irqrestore(&base->lock, flags);
	return ret;
}
MODULE_LICENSE("GPL");