Unix信号之sigaction函数

sigaction函数是除signal函数之外的另一个可以设置信号处理的函数。sigaction用法比signal函数复杂，但是可以对信号处理进行更加精准更灵活的控制。sigaction是POSIX的信号接口,而signal函数是标准C的信号接口，所以sigaction函数的可移植性更强。

sigaction函数说明

函数功能

检查或修改与指定信号相关联的处理动作，可以同时检查和修改。

函数原型

1
2
3
4
5
6
7
8

struct sigaction{
  void (*sa_handler)(int);		//信号处理函数地址
  sigset_t sa_mask;				//信号掩码集，当调用信号处理函数时，程序将阻塞sa_mask中的信号
  int sa_flag;					//位掩码，指定用于控制信号处理过程中的各种选项。
  void (*sa_sigaction)(int,siginfo_t*,void*);	//暂不用
};
int sigaction(int signo,const struct sigaction*restrict act,struct sigaction*restrict oact);

函数参数

• signo : 指定操作的信号

• act : 新修改的sigaction

• oldact : 保存该函数原有的sigaction。

  ​

上述struct sigaction中sa_flag取值说明(常用的有以下两个)：

• SA_NODEFER:当信号处理函数正在进行时，不堵塞对于信号处理函数自身信号功能。
• SA_RESETHAND：当用户注册的信号处理函数被执行过一次后，该信号的处理函数被设为系统默认的处理函数

函数返回值

• 0 : 返回0表示设置成功
• -1 ： 返回-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
26
27
28
29

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
void sighandler(int sig) {
	printf("this is in the sig handler\n");
	for (int i = 0; i < 5; i++) {
		printf("num:%d\n", i);
	}
}
int main() {
	struct sigaction act;
	struct sigaction oldact;
	act.sa_handler = sighandler;
	act.sa_flags = SA_NODEFER ;//| SA_RESETHAND;
	sigaction(SIGINT , &act,&oldact);
	printf ("this is the main function\n");
	pid_t pid = getpid();
	printf("%d", pid);
	kill(pid, SIGINT);
}

Comment and share

判断主机字节序大端规则或小端规则方法

大端规则与小端规则

在计算机存储中存储字节的顺序有两种分别为大端规则和小端规则。

• 小端规则(littel endian)：低序字节存储到内存较低的位置，即起始位置。
• 大端规则(big endian)：低序字节存储到内存较高的位置，即高序字节存储到起始位置。

有一个32位数字为:0x01020304

在小端规则的机器上，其存储如下：

在大端规则机器上，其存储如下：

判断当前机器字节序的方法

判断当前机器为大端规则还是小端规则，其本质是对于一个变量，判断其各字节的存储顺序，

方法一：使用union判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>
using namespace std;
int main() {
	union {
		short a;
		char c[2];
	} u;
	u.a = 0x0102;
	if (u.c[0] == 2 && u.c[1] == 1) {
		std::cout << "little" << std::endl;
	} else if (u.c[0] == 1 && u.c[1] == 2) {
		std::cout << "big" << std::endl;
	} else {
      std::cout << "unkown" << std::endl;
	}
  	return 0;
}

方法二：直接将字节取出,判断顺序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>
using namespace std;
int main() {
	short s = 0x0102;
	char* a = (char*)(&s);
	std::cout << (*a) << std::endl;
	char b = 0x02, c = 0x01;
	if (((*a) | b) == b) {
		std::cout << "little" << std::endl;
	} else if (((*a) | c) == b) {
		std::cout << "big" << std::endl;
	} else {
      	std::cout << "unknow" << std::endl;
	}
  	return 0;
}

Comment and share

pack与aligned的区别

GCC支持用__attribute__为变量、类型、函数以及标签指定特殊属性。其中可以使用attribute的aligned属性控制变量或类型的内存对其规则，之前一篇文章已经提到pack可以改变结构体中各成员之间的内存对其规则。https://langzi989.github.io/2017/10/02/C语言内存对其相关/

其中#pragma pack()和__attribute__((aligned))区别很大。

aligned内存对其详解

使用场景:

• 变量
• 类型

功能说明：

• 当aligned作用于变量时，其作用是告诉编译器为变量分配内存的时候，要分配在指定对其的内存上.作用于变量之上不会改变变量的大小。
  • 例如：int a __attribute__((aligned(16)));该变量a的内存起始地址为16的倍数。
• 当aligned作用于类型时，其作用是告诉编译器该类型声明的所有变量都要分配在指定对齐的内存上。当该属性作用于结构体声明时可能会改变结构体的大小。

1
2
3
4
5
6
7
8

struct Test{
  char a[3];
}__attribute__((aligned(8)));
int main() {
  //8
  std::cout << sizeof(Test);
}

如上所示，当align作用于结构体定义时会改变结构体的大小。结构体最终大小为aligned指定大小的整数倍。

aligned与pack的区别

从上面可以看出，aligned和pack的主要区别如下:

• pack作用于结构体或类的定义，而aligned既可以作用于结构体或类的定义，也可以作用于变量的声明。
• pack的作用是改变结构体或类中成员变量的布局规则，而aligned只是建议编译器对指定变量或指定类型的变量分配内存时的规则。
• pack可以压缩变量所占内存的空间
• align可以指定变量在内存的对其规则，而pack不可以。
• 若某一个结构体的默认pack为n，pack指定的对齐规则m大于n，则该pack忽略。若aligned指定的对齐规则s大于n,则此时结构体的大小一定为s的整数倍。
• aligned和pack指定规则时都必须为2的n次幂。

参考链接：http://blog.shengbin.me/posts/gcc-attribute-aligned-and-packed

Comment and share

fcntl实现对文件加锁功能

之前有一篇文章详细介绍了fcntl的用法,这一节将说明使用fcntl实现对文件加锁的功能，

fcntl函数原型

fcntl函数如下，具体用法可参考上面的文章。

1
2

#include <fcntl.h>
int fcntl(int fd, int cmd, .../*int args or lock args*/);

使用fcntl对文件加锁

当fcntl中的cmd为F_GETLK,F_SETLK,F_SELFKW时为对文件进行锁操作，此时arg参数为flock。注意：使用fcntl对文件加锁，加锁效果类似于自旋锁，只有写写互斥和读写互斥，读读并不互斥。

cmd取值及其操作：

• F_GETLK : 获取当前锁得状态
• F_SETLK : 给当前文件上锁（非阻塞）。
• F_SETLKW : 给当前文件上锁（阻塞，若当前文件正在被锁住，该函数一直阻塞）。

flock结构体定义如下：

1
2
3
4
5
6
7
8

struct flock {
  short int l_type;
  short int l_whence;
  off_t l_start;
  off_t l_len;
  pid_t l_pid;
};

下面对flock中的参数一一解释：

• l_type:此参数表示所得类型。其可能的取值包括一下三个:
  • F_RDLCK : 读锁
  • F_WRLCK : 写锁
  • F_UNLCK : 无锁状态
• l_start : 此参数锁区域的开始位置的偏移量
• l_whence:此参数决定锁开始的位置。其可选参数为:
  • SEEK_SET:当前位置为文件的开头
  • SEEK_CUR:当前位置为文件指针的位置
  • SEEK_END:当前位置为文件末尾
• l_len : 锁定文件的长度

若要锁定整个文件，通常的方法为将l_start设为０，l_whence设为SEEK_SET,l_len设为０．

实例

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

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
void lock_set(int fd, int type) {
	struct flock lock;
	lock.l_whence = SEEK_SET;
	lock.l_start = 0;
	lock.l_len = 0;
	while (1) {
		lock.l_type = type;
		if ((fcntl(fd, F_SETLK, &lock)) == 0) {
			if (lock.l_type == F_RDLCK)
				printf("read lock set by %d\n", getpid());
			else if(lock.l_type == F_WRLCK)
				printf("write lock set by %d\n", getpid());
			else if (lock.l_type == F_UNLCK)
				printf("release lock by %d\n", getpid());
			return;
		}
		//检查文件是否可以上锁
		fcntl(fd, F_GETLK, &lock);
		//判断不能上锁的原因
		if (lock.l_type != F_UNLCK) {
			if (lock.l_type == F_RDLCK)
				printf("read lock has been already set by %d\n", getpid());
			else if (lock.l_type == F_WRLCK)
			printf("write lock has been already set by %d\n", getpid());
			getchar();
		}
	}
}
int main() {
	int fd;
	fd = open("data", O_RDWR | O_CREAT, 0666);
	if (fd < 0) {
		perror("open failed");
		return -1;
	}
	lock_set(fd, F_WRLCK);
	getchar();
	lock_set(fd, F_UNLCK);
	getchar();
	close(fd);
	return 0;
}

Comment and share

记录C/C++库从32位机器向64为机器移植过程中导致的问题和解决方案

最近程序库从32为向64为机器移植后，在使用过程中出现了一些问题，其中包括上一篇中记录的由于va_list类型不一致导致程序core dump或者出现异常行为的原因，这篇文章记录一下库移植之后出现的小问题。持续更新…

问题一: unsigned long int类型长度不兼容并对其按位操作

一般情况下在32位和64位机器单纯使用该类型在不出现数字大小溢出的情况下一般不会出现问题。但是有一种情况需要特别注意，即当对该unsigned long int进行位操作时，此时的操作结果在32和64位机器的操作结果会不同而导致其他问题。

例如使用unsigned long int类型作为key对其按位进行加密或哈希时，这时的加密或哈希结果会出现问题。

解决方法

将unsigned long int类型换为uint32_t在64位机器上重新编译

问题二： 32位和64位默认对齐不同导致数据类型大小不同

在linux系统下，32位机器数据默认以4字节对齐，64为机器默认以8字节对齐。

看如下结构构体:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <iostream>
struct Test{
  int a;
  char* data[0];
};
int main() {
  std::cout << sizeof(Test) << std::endl;
  Test t;
  std::cout << "&t:" << &t << std::endl
            << "&t.a" << &t.a << std::endl
            << "&t.data:" << &t.data << std::endl;
  return 0;
}

32位机器运行结果:

1
2
3
4

8
&t:0x7ffd49f978b0
&t.a0x7ffd49f978b0
&t.data:0x7ffd49f978b4

64位机器运行结果:

1
2
3
4

8
&t:0x7ffd49f978b0
&t.a0x7ffd49f978b0
&t.data:0x7ffd49f978b8

解决方案:

在声明结构体前面加上#pragma pack(1)或#pragma pack(4)，强制改变结构体的对齐方式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <iostream>
#pragma pack(4)
struct Test{
  int a;
  char* data[0];
};
int main() {
  std::cout << sizeof(Test) << std::endl;
  Test t;
  std::cout << "&t:" << &t << std::endl
            << "&t.a" << &t.a << std::endl
            << "&t.data:" << &t.data << std::endl;
  return 0;
}

Comment and share

C中va_list在32位和64位机器的区别与差异

在将程序从32位机器移植到64位机器的过程中经常出现一些奇奇怪怪的错误,这里记录一下在使用可变参数的过程中导致在32位机器上正常运行的程序移植到64位机器上之后出现段错误的发现过程以及解决方案。

首先看下面一段代码:

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

#include <iostream>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
void parse(va_list ap) {
  char* arg;
  arg = va_arg(ap, char*);
  std::cout << arg << std::endl
            << strlen(arg) << std::endl;
}
void test(const char* format, ...) {
  va_list ap;
  va_start(ap, format);
  for (int i = 0; i < 2; i++) {
    parse(ap);
  }
  va_end(ap);
}
int main() {
  test("hget %s %s", "abc", "123456");
}

在32位机器的运行结果如下:

1
2
3
4

abc
3
abc
3

在64位机器运行结果如下:

1
2
3
4

abc
3
123456
6

原因分析

出现上述结果的原因是由于va_list类型在32位和64位机器的类型不同导致的.

32位va_list

在32位上,va_list的定义为:

1
2

//注意，由于中间宏过多，这里省去了中间如_VA_LIST宏，直接给出实际定义。
typedef va_list char**;

64位va_list

在64位上va_list定义为一个结构体数组，并且数组中记录了可变参数被读的偏移量：

1
2
3
4
5
6
7

// Figure 3.34
typedef struct {
   unsigned int gp_offset;
   unsigned int fp_offset;
   void *overflow_arg_area;
   void *reg_save_area;
} va_list[1];

程序异常分析

当在32位机器上将va_list(char**)作为参数传递给函数的时候，该函数将从头开始读取该变长参数，还是使用va_list完毕并不记录当前va_list被读的偏移量，所以当第二次传入该va_list还是从头开始读取。

当在64为机器上将va_list(struct 数组)作为参数传递给函数的时候，该函数读取va_list完毕之后，将读取的偏移量记录在结构体中，由于其为数组传入函数，所以该被调用的函数改变了传入的va_list的偏移量。导致下次调用该函数从记录的偏移量开始读,造成不可预测或者内存越界等问题。

移植解决方案

将va_list初始化写到for循环内部，每次调用函数前都初始化va_list即可。

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

#include <iostream>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
void parse(va_list ap) {
  char* arg;
  arg = va_arg(ap, char*);
  std::cout << arg << std::endl
            << strlen(arg) << std::endl;
}
void test(const char* format, ...) {
  for (int i = 0; i < 2; i++) {
    va_list ap;
    va_start(ap, format);
    parse(ap);
    va_end(ap);
  }
}
int main() {
  test("hget %s %s", "abc", "123456");
}

参考:
https://stackoverflow.com/questions/4958384/what-is-the-format-of-the-x86-64-va-list-structure
http://blog.csdn.net/doubleface999/article/details/55798710

Comment and share

C中snprintf与vsnprintf函数

虽然snprintf函数在开发过程中比较常用,但是其中有一些细节性的问题需要注意。因为snprintf函数不是C中的标准函数，不同的编译器可能对该函数的实现不同，本文说明是基于GCC编译器。

snprintf函数

函数原型

snprintf函数的作用是将格式化的数据写入字符串。其函数原型如下:

1

snprintf(char* buffer, int n, char* format, ...);

参数说明

• buffer : 存储格式化字符串的buffer
• n : 指定格式化字符串的大小,包括\0
• format : 指定需要格式化字符串的format
• … : 可变参数

返回值

该函数的返回值为其期望字符串的长度，而不是实际存入buffer中的字符串的长度。且不包括\0。

注意点

特别注意函数原型中的第二个参数包括\0的大小，而返回值为期望大小且不包括\0。

例:

1
2
3
4
5
6
7
8

char buffer[256];
//返回值ret = 13,buffer中的内容为123456789
int ret = snprintf(buffer, 10, "%s", "1234567890abc");
memset(buffer, 0x0, sizeof(buffer));
//返回值ret = 3,buffer中的内容为123
ret =snprintf(buffer, 10, "%s", "123");

snprintf与vsnprintf

snprintf和vsnprintf都是C语言printf家族函数的成员。实际上，snprintf和vsnprintf功能完全一样，只是vsnprintf将snprintf中的可变参数换成了av_list类型。如下:

1
2
3
4
5

#include <stdio.h>
int printf(const char* format, ...); //输出到标准输出
int fprintf(FILE* stream, const char* format, ...); //输出到文件
int sprintf(char* buffer, const char* format, ...);   //输出到字符串
int snprintf(char* buffer, int n, const char* format, ...);   //输出到字符串

1
2
3
4
5

#include <stdarg.h>
int vprintf(const char* format, va_list ap); //输出到标准输出
int vfprintf(FILE* stream, const char* format, va_list ap); //输出到文件
int vsprintf(char* buffer, const char* format, va_list ap);   //输出到字符串
int vsnprintf(char* buffer, int n, const char* format, va_list ap);   //输出到字符串

va_list获取

可变参数va_list获取方式通过下列函数获取,并且总是成对调用

1
2

va_start(va_list ap, last);
va_end(va_list ap);

简单的使用vsnprintf函数实现snprintf

1
2
3
4
5
6
7
8
9
10

#include <stdio.h>
#include <stdarg.h>
int my_snprintf(char* buffer, int size, const char* format, ...) {
  va_list ap;
  va_start(ap, format);
  int ret = vsnprintf(buffer, size, format, ap);
  va_end(ap);
  return ret;
}

Comment and share