kk Blog —— 通用基础

date [-d @int|str] [+%s|"+%F %T"]

linux 下的浮点运算

linux 下的浮点运算

  1. intel 平台下,如果有浮点计算,都会用专门的浮点指令来执行。但是double/float 类型的加减乘除,gcc 是用的一般指令来做的,没有用浮点指令来做。

  2. 还是intel 平台下,一个进程在被cpu调度到之后,运行的第一条浮点指令会触发“no deveice avaible”异常,从而导致执行相应的中断处理程序。后续的不再触发。这个中断处理程序中,一般会做的是,恢复/保存浮点运行相关的环境。如果该时间段内没有浮点操作,那么就不用恢复/保存浮点运行环境,从而减少开销。这也是为什么要设计成这样的原因。

  3. 内核也可以执行浮点操作,只需要调用前后用 kernel_fpu_begin() and kernel_fpu_end() 括起来。但是有可能这个的开销已经超过了用浮点指令带来的便捷。所以内核应该尽量少用浮点操作。


Linux内核与浮点计算

在Linux内核里无法直接进行浮点计算,这是从性能上的考虑,因为这样做可以省去在用户态与内核态之间进行切换时保存/恢复浮点寄存器 FPU的操作,当然,这到底可以提升多少性能我还不得而知,不过就目前而言,Linux内核的确就是这样做的。

比如下面这个测试模块:

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
# Makefile
MDIR = $(shell pwd)
ifeq (, $(KSRC))
	KSRC := /usr/src/linux-`uname -r`
endif

ifeq (, $(PROJECT_DIR))
	PROJECT_DIR := $(PWD)/../
endif

module := float_test

obj-m := $(module).o

srcs =  $(wildcard, *.c)

$(module)-objs := $(addsuffix .o, $(basename $(srcs)))

EXTRA_CFLAGS += -g $(FLAG) -I$(PROJECT_DIR)/inc -I${SHAREDHDR} -I$(KERNELHDR) -O2 -D__KERNEL__ -DMODULE $(INCLUDE) -DEXPORT_SYMTAB

TARGET = $(module).ko

all:
	make -C $(KSRC) M=$(MDIR) modules

debug:
	make EXTRA_FLAGS="${EXTRA_CFLAGS} -DDEBUG" -C $(KSRC) M=$(MDIR) modules

clean:
	make -C $(KSRC) M=$(MDIR) clean

install: all
	cp -f $(TARGET) $(INSTALL_DIR)
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
/**
 * float_test.c
 */
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/stddef.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <asm/desc.h>

static float float_test(float a, float b)
{
	return a/b;
}

static int __init test_module_init(void)
{
	float_test(1.0, 1.0);
	return 0;
}

static void __exit test_module_fini(void)
{

	//Do Nothing
	return;
}

module_init(test_module_init);
module_exit(test_module_fini);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("lenky0401 at gmail dot com");

编译它将得到如下错误提示:

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
[root@localhost t]# make
make -C /usr/src/linux-`uname -r` M=/home/gqk/t modules
make[1]: Entering directory `/usr/src/linux-2.6.38.8'
  CC [M]  /home/gqk/t/float_test.o
/home/gqk/t/float_test.c: In function ‘float_test’:
/home/gqk/t/float_test.c:12: error: SSE register return with SSE disabled
make[2]: *** [/home/gqk/t/float_test.o] Error 1
make[1]: *** [_module_/home/gqk/t] Error 2
make[1]: Leaving directory `/usr/src/linux-2.6.38.8'
make: *** [all] Error 2
[root@localhost t]#

[root@localhost t]# make V=1
make -C /usr/src/linux-`uname -r` M=/home/gqk/t modules
make[1]: Entering directory `/usr/src/linux-2.6.38.8'
test -e include/generated/autoconf.h -a -e include/config/auto.conf || (        \
	echo;                               \
	echo "  ERROR: Kernel configuration is invalid.";       \
	echo "         include/generated/autoconf.h or include/config/auto.conf are missing.";\
	echo "         Run 'make oldconfig && make prepare' on kernel src to fix it.";  \
	echo;                               \
	/bin/false)
mkdir -p /home/gqk/t/.tmp_versions ; rm -f /home/gqk/t/.tmp_versions/*
make -f scripts/Makefile.build obj=/home/gqk/t
  gcc -Wp,-MD,/home/gqk/t/.float_test.o.d  -nostdinc -isystem /usr/lib/gcc/x86_64-redhat-linux/4.4.4/include -I/usr/src/linux-2.6.38.8/arch/x86/include -Iinclude  -include include/generated/autoconf.h -D__KERNEL__ -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs -fno-strict-aliasing -fno-common -Werror-implicit-function-declaration -Wno-format-security -fno-delete-null-pointer-checks -O1 -m64 -mtune=generic -mno-red-zone -mcmodel=kernel -funit-at-a-time -maccumulate-outgoing-args -fstack-protector -DCONFIG_AS_CFI=1 -DCONFIG_AS_CFI_SIGNAL_FRAME=1 -DCONFIG_AS_CFI_SECTIONS=1 -DCONFIG_AS_FXSAVEQ=1 -pipe -Wno-sign-compare -fno-asynchronous-unwind-tables -mno-sse -mno-mmx -mno-sse2 -mno-3dnow -Wframe-larger-than=2048 -fno-omit-frame-pointer -fno-optimize-sibling-calls -g -Wdeclaration-after-statement -Wno-pointer-sign -fno-strict-overflow -fconserve-stack -DCC_HAVE_ASM_GOTO -g -I/home/gqk/t/..//inc -I -I -O2 -D__KERNEL__ -DMODULE -DEXPORT_SYMTAB  -DMODULE  -D"KBUILD_STR(s)=#s" -D"KBUILD_BASENAME=KBUILD_STR(float_test)"  -D"KBUILD_MODNAME=KBUILD_STR(float_test)" -c -o /home/gqk/t/.tmp_float_test.o /home/gqk/t/float_test.c
/home/gqk/t/float_test.c: In function ‘float_test’:
/home/gqk/t/float_test.c:12: error: SSE register return with SSE disabled
make[2]: *** [/home/gqk/t/float_test.o] Error 1
make[1]: *** [_module_/home/gqk/t] Error 2
make[1]: Leaving directory `/usr/src/linux-2.6.38.8'
make: *** [all] Error 2
[root@localhost t]#

注意到其中的gcc编译选项:-mno-sse -mno-mmx -mno-sse2,这几个选项是Linux内核编译模块时自动带上的,就是它们(具体就是-mno-sse)明确禁止了Linux内核无法使用浮点数。

在Linux内核里很少会有使用浮点数的需求,即便是有也大多是通过变通的办法解决,在下面链接里有一些很好的扩展介绍,感兴趣的可以看看:

http://stackoverflow.com/questions/6397430/overhead-of-supporting-floating-point-arithmetic-inside-the-linux-kernel

http://stackoverflow.com/questions/10212892/how-to-avoid-fpu-when-given-float-numbers

http://www.linuxsmiths.com/blog/?p=253


http://blog.csdn.net/vbskj/article/details/38408467

c scanf/fscanf 的%n和%[]使用方法

http://blog.csdn.net/wesweeky/article/details/6439777

一、

%n说明符输出有效字符数量,%n在scanf和printf中都可使用。与%n相对应的形参是一个int类型的指针,%n不影响scanf和printf的返回值。例如:

1
scanf("%d %d%n", &i, &j, &k);

如果输入434 6434,则k等于8,而scanf的返回值仍然为2。又如:

1
scanf("%c%n", &ch, &k);

输入“sbcdefdg”后,k等于1,而不是8,因为%c只取一个字符,%n输出的是有效字符数量。

%n用在printf函数里,表示输出的字符数量,例如:

1
printf("i=%d, j=%d/n%n", i, j, &k);

在i=343、j=123的情况下,k=12,同时%n不影响printf的返回值,其返回值仍然为12,而不是14。

二、

众所周之,scanf以空白字符为定界符,但如果输入的字符串是以其它字符为定界符的,那怎么办?[]就是专门处理这个问题的转换说明符。[]转换说明符可以通过两种方式产生结果字符集,如果第一个[字符右边没有抑扬符(^),那么处于[]之间的字符就是结果字符集,不在其中的可输入字符都作为定界符;如果左边[符号紧靠一个抑扬符(^),那么意义相反,^和]之间的字符是定界符,其余可输入字符是结果字符集。

在使用[]说明符之前,得先明白两个概念:一是扫描列表。扫描列表(scanlist)指的是包含在[和]两个字符之间除紧靠左边[字符的抑扬符之外的字符,例如:

1
scanf("%[abcd]", ptr);

abcd组成扫描列表。二是扫描字符集(scanset)。扫描字符集指的是结果字符集,例如上面的例子,结果字符集就是abcd。如果输入一个字符串“cbadkjf”,那么ptr得到的字符串是cbad,kjf三个字符都属于定界符,输入到k字符时输入字符串被截断,kjf三个字符被留在stdin里面。如果带有抑扬符,例如:

1
scanf("%[^abcd]", ptr);

扫描列表仍然是abcd,但扫描字符集是除abcd外的可输入字符。如果输入字符串“jksferakjjdf”,ptr得到的字符串是“jksfer”。如果想限制输入字符串的字符数量,可以象s说明符那样,在[]前面使用位域,例如:

1
scanf("%10[^abcd]", ptr);

这样结果字符串最多只能包含10个字符(除'/0'字符外)。

[符号可以作为扫描列表中的一个成员,但]字符除紧贴最左边的[字符或抑扬符两种情况外,其余情况下都不会被看作扫描列表的成员。例如“%[]abcd]”或者“%[^]abcd]”,上述两种情况下]字符属于扫描列表的成员,但如果是“%[ab]cd]”,中间的]字符不会被看作扫描列表的成员,而且输入输出的结果会是乱七八糟的。

对于减号-,只有在紧贴[字符或抑扬字符以及作为扫描列表最后一个成员时,-字符才会被视为扫描列表的成员。c标准把其余情况规定为编译器相关的。大多数编译器把这种情况的减号定义为连字符,例如:

1
scanf("%[a-zA-Z]", ptr);

那么扫描列表由大小写各26个字母组成。少数编译器仍旧把这种情况下的减号视为扫描列表成员。

1
fscanf(fd,"%*[^/n]/n"); // %*是虚读,没有存,只是让指针跳过了这个变量!

sk 的锁,spin_lock_bh、lock_sock

一、修改sk的锁 sk_lock.slock

tcp协议栈对struct sock sk有两把锁,第一把是sk_lock.slock,第二把则是sk_lock.owned。sk_lock.slock用于获取struct sock sk对象的成员的修改权限;sk_lock.owned用于区分当前是进程上下文或是软中断上下文,为进程上下文时sk_lock.owned会被置1,中断上下文为0。

如果是要对sk修改,首先是必须拿锁sk_lock.slock,其后是判断当前是软中断或是进程上下文,如果是进程上下文,那么一般也不能修改sk

中断上下文可以用下面的锁,也就是下面的锁只有 spin_lock

1
2
3
4
5
6
/* BH context may only use the following locking interface. */
#define bh_lock_sock(__sk)      spin_lock(&((__sk)->sk_lock.slock))
#define bh_lock_sock_nested(__sk) \
				spin_lock_nested(&((__sk)->sk_lock.slock), \
				SINGLE_DEPTH_NESTING)
#define bh_unlock_sock(__sk)    spin_unlock(&((__sk)->sk_lock.slock))

非中断上下文可以直接用 spin_lock_bh(&((sk)->sk_lock.slock))

获得sk_lock.slock 锁后还要判断 sock_owned_by_user(sk), 如果被进程上下文占用也一般不能操作sk

1
#define sock_owned_by_user(sk)  ((sk)->sk_lock.owned)

二、进程上下文获取sk

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
static inline void lock_sock(struct sock *sk)
{
	lock_sock_nested(sk, 0);
}

void lock_sock_nested(struct sock *sk, int subclass)
{
	might_sleep();

	// 先获取 sk_lock.slock 锁
	spin_lock_bh(&sk->sk_lock.slock);
	// 如果有进程占用sk,则调__lock_sock等待占用sk的进程结束
	if (sk->sk_lock.owned)
		__lock_sock(sk);

	// 此时占用sk的进程结束了,但前进程就可以占用sk
	sk->sk_lock.owned = 1;
	// 进程占用sk时不占 sk_lock.slock
	spin_unlock(&sk->sk_lock.slock);

	/*
	 * The sk_lock has mutex_lock() semantics here:
	 */
	mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
	local_bh_enable();
}

static void __lock_sock(struct sock *sk)
	__releases(&sk->sk_lock.slock)
	__acquires(&sk->sk_lock.slock)
{
	DEFINE_WAIT(wait);

	for (;;) {
		prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
					TASK_UNINTERRUPTIBLE);
		spin_unlock_bh(&sk->sk_lock.slock);
		schedule();
		spin_lock_bh(&sk->sk_lock.slock);
		if (!sock_owned_by_user(sk))
			break;
	}
	finish_wait(&sk->sk_lock.wq, &wait);
}
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
void release_sock(struct sock *sk)
{
	/*
	 * The sk_lock has mutex_unlock() semantics:
	 */
	mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);

	spin_lock_bh(&sk->sk_lock.slock);
	if (sk->sk_backlog.tail)
		__release_sock(sk); // 处理backlog的包

	/* Warning : release_cb() might need to release sk ownership,
	 * ie call sock_release_ownership(sk) before us.
	 */
	if (sk->sk_prot->release_cb)
		sk->sk_prot->release_cb(sk);

	// 获取sk_lock.slock,然后清除 sk_lock.owned
	sock_release_ownership(sk);
	if (waitqueue_active(&sk->sk_lock.wq))
		wake_up(&sk->sk_lock.wq);
	spin_unlock_bh(&sk->sk_lock.slock);
}

static inline void sock_release_ownership(struct sock *sk)
{
	sk->sk_lock.owned = 0;
}

本地IP包分片--local_df,ignore_df

local_df 和 ignore_df 是一个意思,在某个版本rename了

ip_queue_xmit 函数中有:

1
2
3
4
if (ip_dont_fragment(sk, &rt->dst) && !skb->ignore_df)
	iph->frag_off = htons(IP_DF);
else
	iph->frag_off = 0;

ip_dont_fragment

1
2
3
4
5
6
7
static inline
int ip_dont_fragment(struct sock *sk, struct dst_entry *dst)
{
	return  inet_sk(sk)->pmtudisc == IP_PMTUDISC_DO ||
		(inet_sk(sk)->pmtudisc == IP_PMTUDISC_WANT &&
		 !(dst_metric_locked(dst, RTAX_MTU)));
}

一般情况下都是开启pmtu、skb->ignore_df = 0, 所以 iph->frag_off = htons(IP_DF);

ip_queue_xmit -> ip_finish_output -> ip_fragment :

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
static int ip_fragment(struct sock *sk, struct sk_buff *skb,
	       unsigned int mtu, 
	       int (*output)(struct sock *, struct sk_buff *))
{
	struct iphdr *iph = ip_hdr(skb);

	// 如果需要分片,直接进入分片函数
	if ((iph->frag_off & htons(IP_DF)) == 0)
		return ip_do_fragment(sk, skb, output);

	// 如果没设置分片,或手动设置的分片过大,则直接丢弃
	if (unlikely(!skb->ignore_df ||
		     (IPCB(skb)->frag_max_size &&
		      IPCB(skb)->frag_max_size > mtu))) {
		struct rtable *rt = skb_rtable(skb);
		struct net_device *dev = rt->dst.dev;

		IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
		icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
			  htonl(mtu));
		kfree_skb(skb);
		return -EMSGSIZE;
	}

	// 所以设置 skb->ignore_df = 1 且 skb->len > mtu 则执行到这里
	return ip_do_fragment(sk, skb, output);
}

所以设置 skb->ignore_df = 1 且 skb->len > mtu 则执行 ip_do_fragment 进行IP分片,

分片是按网卡mtu进行,如果mss小于网卡mtu-40,则需要设置 IPCB(skb)->frag_max_size

iph->frag_off 定义

1
2
3
#define IP_DF           0x4000          /* Flag: "Don't Fragment"       */
#define IP_MF           0x2000          /* Flag: "More Fragments"       */
#define IP_OFFSET       0x1FFF          /* "Fragment Offset" part       */

1) 不分片的包 iph->frag_off = htons(IP_DF)
2) 最后一个分片包 ((ntohs(iph->frag_off) & IP_OFFSET) > 0)
3) 其余分片包 ((ntohs(iph->frag_off) & IP_OFFSET) > 0 && (iph->frag_off & htons(IP_MF)) > 0)

iptables

http://blog.csdn.net/l241002209/article/details/43987933

1、添加

添加规则有两个参数:-A和-I。其中
-A是添加到规则的末尾;
-I可以插入到指定位置,没有指定位置的话默认插入到规则的首部。

2、查看

1
2
3
4
5
6
iptables -nvL –line-number

 -L 查看当前表的所有规则,默认查看的是filter表,如果要查看NAT表,可以加上-t NAT参数
 -n 不对ip地址进行反查,加上这个参数显示速度会快很多
 -v 输出详细信息,包含通过该规则的数据包数量,总字节数及相应的网络接口
 –line-number 显示规则的序列号,这个参数在删除或修改规则时会用到

3

1
2
3
4
5
6
7
8
9
10
iptables -nvL
iptables -F # 清除所有规则,但不改变默认策略
iptables -P INPUT ACCEPT  # INPUT 默认策略
iptables -P OUTPUT ACCEPT # OUTPUT 默认策略

iptables -I INPUT -s 192.168.1.5 -j DROP # 头部插入
iptables -A INPUT -p tcp --dport 22 -j ACCEPT # 尾部追加,规则按顺序匹配的,匹配到就返回

iptables -D INPUT -s 192.168.1.5 -j DROP
iptables -D INPUT 2

4、修改 修改使用-R参数

1
iptables -R INPUT 3 -j ACCEPT

https://blog.csdn.net/zqixiao_09/article/details/53401321

NAT地址转换

iptables nat 原理

同filter表一样,nat表也有三条缺省的"链"(chains):

PREROUTING:目的DNAT规则

把从外来的访问重定向到其他的机子上,比如内部SERVER,或者DMZ。

因为路由时只检查数据包的目的ip地址,所以必须在路由之前就进行目的PREROUTING DNAT; 系统先PREROUTING DNAT翻译——>再过滤(FORWARD)——>最后路由。 路由和过滤(FORWARD)中match 的目的地址,都是针对被PREROUTING DNAT之后的。

POSTROUTING:源SNAT规则

在路由以后在执行该链中的规则。

系统先路由——>再过滤(FORWARD)——>最后才进行POSTROUTING SNAT地址其match 源地址是翻译前的。

OUTPUT:定义对本地产生的数据包的目的NAT规则

内网访问外网 -J SNAT

-j SNAT 源网络地址转换,SNAT就是重写包的源IP地址, SNAT 只能用在nat表的POSTROUTING链里

固定public 地址(外网接口地址)的最基本内访外SNAT

1
iptables -t nat -A POSTROUTING -s 192.168.0.0/24 -o eth0 -j SNAT --to 你的eth0地址

-j MASQUERADE

用于外网口public地址是DHCP动态获取的(如ADSL)

1
2
iptables -t nat  -A POSTROUTING –o eth1 –s 192.168.1.0/24 –j MASQUERADE
iptables -t nat  -A POSTROUTING -o ppp0  -j  MASQUERADE

外网访问内网 –J DNT

DNAT:目的网络地址转换,重写包的目的IP地址

典型的DNAT的例子

外部接口ip:210.83.2.206 内部接口ip:192.168.1.1

ftp服务器 : ip 192.168.1.3 web服务器 : ip 192.168.1.4

1
2
iptables -t nat -A PREROUTING -d 210.83.2.206 -p tcp --dport 21 -j DNAT --to 192.168.1.3
iptables -t nat -A PREROUTING -d 210.83.2.206 -p tcp --dport 80 -j DNAT --to 192.168.1.4

DNAT用于内部SERVER的load-balance(即CISCO的rotery)

1
iptables –t nat –A PREROUTING –d 219.142.217.161 –j DNAT --to-destination 192.168.1.24-192.168.1.25
DNAT 带端口映射(改变SERVER的端口)

一个FTP SERVER从内部192.168.100.125:21映射到216.94.87.37:2121的例子

1
iptables -t nat -A PREROUTING -p tcp -d 216.94.87.37 --dport 2121 -j DNAT --to-destination 192.168.100.125:21