分类 技术志 下的文章

线程函数参数引发的问题

上午我们的一个实施组从现网发回来一封邮件,接到这种邮件一般都是报告问题的,果然不出所料,现场出现一个core,经过分析这是个由于线程函数参数存储位置不当造成的,从中我们可以总结出一些经验,以避免以后再犯。

我采用下面的一个例子来模拟问题的出现:

#include <pthread.h>
#include <errno.h>
#include <stdio.h>

typedef struct foo {
        char c[10];
        int  *p;
} foo;

void *thread_func(void *para) {
        foo     *p      = (foo*)para;
        sleep(5); //等待以让gen_thread先退出
        printf("[thr2-1]: the foo’s str is %s\n", p->c);
        printf("[thr2-1]: the foo’s p is %d\n", *(p->p));
        *(p->p) = 10;
        strcpy(p->c, "Bye, Tony");
        printf("[thr2-2]: the foo’s str is %s\n", p->c);
        printf("[thr2-2]: the foo’s p is %d\n", *(p->p));
        return;
}

pthread_t gen_thread() {
        pthread_t       id;
        int             rv;
        int             i       = 0;
        foo             f;

        memset(&f, 0, sizeof(foo));
        strcpy(f.c, "HelloTony");
        f.p = &i;

        printf("[thr1]: the foo’s str is %s\n", f.c);
        printf("[thr1]: the foo’s p is %d\n", *(f.p));

        rv = pthread_create(&id, NULL, (void*)thread_func, (void*)&f);
        if (rv != 0) {
                printf("create pthread error, errno is %d!\n", errno);
                exit (1);
        }

        return id;
}

int main() {
        pthread_join(gen_thread(), NULL);
        return 0;
}

编译执行:
a.out
[thr1]: the foo’s str is HelloTony
[thr1]: the foo’s p is 0
[thr2-1]: the foo’s str is 旷
[thr2-1]: the foo’s p is 0
[thr2-2]: the foo’s str is Bye, Tony
[thr2-2]: the foo’s p is 10
段错误 ((主存储器)信息转储)

我们来分析一下出现core的过程,gen_thread函数在创建一个新的线程后退出,而在创建新的线程时,传给线程函数的参数是存储在gen_thread函数的栈上的局部变量。而在gen_thread退出后,新线程的线程函数对线程参数进行了修改,其结果就相当于修改了主线程的栈上的数据,而当系统调用访问主线程的栈数据时,这些数据已经被修改,导致系统调用访问到’非法地址’而Dump Core。

当然上面的例子是’臆造’出来的,这也是我们的系统在一个特殊情况下出现的问题,在以前的测试中从未发生。但是我们系统使用栈上变量作为线程函数参数,这确是一潜在的问题,尽管这种问题的发生几率很小。

那么如何解决这一问题呢?眼前就有两个办法:
1、使用全局变量或者是STATIC变量
在上面的例子中,如果我们把foo f拿到函数外,并声明为static foo f,那么Core就不会出现,因为STATIC变量存储在BSS段中,其Scope也是全局的(文件Scope的全局)。所以即使gen_thread返回,存储f的区域仍然是合法的。但是这样做的一个缺点就是:如果新创建多个线程的话,那么这些线程就会共享该参数了,这是一个需要考虑的问题,但是这种情况也许会是用于某些场合。

2、在堆上动态分配变量
在堆上分配变量,既可以避免使用局部变量的’非法访问’问题,也可以避免多个线程共享的问题,针对每创建一个新线程,我们都malloc一块内存,将这块内存地址作为参数传给线程函数。这样做也不是没有弊端,因为动态分配内存,所以你就需要自己管理内存,找到时机释放它。

还有一种方法叫’线程局部存储(Thread Local Storage,TLS)’,应该专门针对第一种办法的,针对声明为全局的或者STATIC的变量,给每个线程提供一份COPY,保证互不干扰。当然这种技术需要编译器的扩展支持,目前不常用,这里也就不多说了。

总之,通过对上面这个问题地分析,我们应该在使用线程的时候注意线程参数的存储方式,这才是我们讨论这个问题的目的。

美妙的文件描述符传递

我们知道父进程在子进程被fork出来之前打开的文件描述符是能被子进程继承下来的,但是一旦子进程已经创建后,父进程打开的文件描述符要怎样才能传递给子进程呢?Unix提供相应的技术来满足这一需求,这就是同一台主机上进程间的文件描述符传递,很美妙而且强大的技术。

想象一下我们试图实现一个服务器,接收多个客户端的连接,我们欲采用多个子进程并发的形式来处理多客户端的同时连接,这时候我们可能有两种想法:
1、客户端每建立一条连接,我们fork出一个子进程负责处理该连接;
2、预先创建一个进程池,客户端每建立一条链接,服务器就从该池中选出一个空闲(Idle)子进程来处理该连接。
后者显然更高效,因为减少了子进程创建的性能损耗,反应的及时性大大增强。这里恰恰就出现了我们前面提到的问题,所有子进程都是在服务器Listen到一条连接以前就已经fork出来了,也就是说新的连接描述符子进程是不知道的,需要父进程传递给它,它接收到相应的连接描述符后,才能与相应的客户端进行通信处理。这里我们就可以使用’传递文件描述符’的方式来实现。

在’UNIX网络编程第1卷’的14.7小节中对这种技术有详细的阐述,实际上这种技术就是利用sendmsg和recvmsg在一定的UNIX域套接口(或者是某种管道)上发送和接收一种特殊的消息,这种消息可以承载’文件描述符’罢了,当然操作系统内核对这种消息作了特殊的处理。在具体一点儿’文件描述符’是作为辅助数据(Ancillary Data)通过msghdr结构中的成员msg_control(老版本中称为msg_accrights)发送和接收的。值得一提的是发送进程在将’文件描述符’发送出去后,即使立即关闭该文件描述符,该文件描述符对应的文件设备也没有被真正的关闭,其引用计数仍然大于一,直到接收进程成功接收后,再关闭该文件描述符,如果这时文件设备的引用计数为0,那么才真正关闭该文件设备。

OK,下面是一个简单的文件描述符传递的例子,该例子实现这样一个功能:即子进程负责在父进程传递给它的文件描述符对应的文件尾加上特定的’LOGO’字符串。例子环境为Solaris 9 + GCC 3.2

/* test_fdpass.c */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

#include <sys/socket.h> /* for socketpair */

#define MY_LOGO         "– Tony Bai"

static int send_fd(int fd, int fd_to_send)
{
        struct iovec    iov[1];
        struct msghdr   msg;
        char            buf[1];

        if (fd_to_send >= 0) {
                msg.msg_accrights       = (caddr_t)&fd_to_send;
                msg.msg_accrightslen    = sizeof(int);
        } else {
                msg.msg_accrights       = (caddr_t)NULL;
                msg.msg_accrightslen    = 0;
        }

        msg.msg_name    = NULL;
        msg.msg_namelen = 0;

        iov[0].iov_base = buf;
        iov[0].iov_len  = 1;
        msg.msg_iov     = iov;
        msg.msg_iovlen  = 1;

        if(sendmsg(fd, &msg, 0) < 0) {
                printf("sendmsg error, errno is %d\n", errno);
                return errno;
        }

        return 0;
}

static int recv_fd(int fd, int *fd_to_recv)
{
        struct iovec    iov[1];
        struct msghdr   msg;
        char            buf[1];

        msg.msg_accrights       = (caddr_t)fd_to_recv;
        msg.msg_accrightslen    = sizeof(int);

        msg.msg_name    = NULL;
        msg.msg_namelen = 0;

        iov[0].iov_base = buf;
        iov[0].iov_len  = 1;
        msg.msg_iov     = iov;
        msg.msg_iovlen  = 1;

        if (recvmsg(fd, &msg, 0) < 0) {
                return errno;
        }

        if(msg.msg_accrightslen != sizeof(int)) {
                *fd_to_recv = -1;
        }

        return 0;
}

int x_sock_set_block(int sock, int on)
{
        int             val;
        int             rv;

        val = fcntl(sock, F_GETFL, 0);
        if (on) {
                rv = fcntl(sock, F_SETFL, ~O_NONBLOCK&val);
        } else {
                rv = fcntl(sock, F_SETFL, O_NONBLOCK|val);
        }

        if (rv) {
                return errno;
        }

        return 0;
}

int main() {
        pid_t   pid;
        int     sockpair[2];
        int     rv;
        char    fname[256];
        int     fd;

        rv = socketpair(AF_UNIX, SOCK_STREAM, 0, sockpair);
        if (rv < 0) {
                printf("Call socketpair error, errno is %d\n", errno);
                return errno;
        }

        pid = fork();
        if (pid == 0) {
                /* in child */
                close(sockpair[1]);

                for ( ; ; ) {
                        rv = x_sock_set_block(sockpair[0], 1);
                        if (rv != 0) {
                                printf("[CHILD]: x_sock_set_block error, errno is %d\n", rv);
                                break;
                        }

                        rv = recv_fd(sockpair[0], &fd);
                        if (rv < 0) {
                                printf("[CHILD]: recv_fd error, errno is %d\n", rv);
                                break;
                        }

                        if (fd < 0) {
                                printf("[CHILD]: child process exit normally!\n");
                                break;
                        }

                       /* 处理fd描述符对应的文件 */
                        rv = write(fd, MY_LOGO, strlen(MY_LOGO));
                        if (rv < 0) {
                                printf("[CHILD]: write error, errno is %d\n", rv);
                        } else {
                                printf("[CHILD]: append logo successfully\n");
                        }
                        close(fd);
                }

          
      exit(0);
        }

        /* in parent */
        for ( ; ; ) {
                memset(fname, 0, sizeof(fname));
                printf("[PARENT]: please enter filename:\n");
                scanf("%s", fname);

                if (strcmp(fname, "exit") == 0) {
                        rv = send_fd(sockpair[1], -1);
                        if (rv < 0) {
                                printf("[PARENT]: send_fd error, errno is %d\n", rv);
                        }
                        break;
                }

                fd = open(fname, O_RDWR | O_APPEND);
                if (fd < 0) {
                        if (errno == ENOENT) {
                                printf("[PARENT]: can’t find file ‘%s’\n", fname);
                                continue;
                        }
                        printf("[PARENT]: open file error, errno is %d\n", errno);
                }

                rv = send_fd(sockpair[1], fd);
                if (rv != 0) {
                        printf("[PARENT]: send_fd error, errno is %d\n", rv);
                }

                close(fd);
        }

        wait(NULL);
        return 0;
}

编译:gcc -o test_fdpass -lsocket -lnsl test_fdpass.c
执行:test_fdpass(事先在同一目录下创建一个文件kk.log)

[PARENT]: please enter filename:
kk.log
[CHILD]: append logo successfully
[PARENT]: please enter filename:
cc.log
[PARENT]: can’t find file ‘cc.log’
exit
[CHILD]: child process exit normally!

你可以发现kk.log内容的末尾已经加上了我的独特LOGO ‘– Tony Bai’。^_^
关于文件描述符传递的更多细节, W. Richard Stevens的’UNIX网络编程第1卷’和’UNIX环境高级编程’两本书中都有详细说明,参读即可。

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 Go语言编程指南
商务合作请联系bigwhite.cn AT aliyun.com

欢迎使用邮件订阅我的博客

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats