fcntl 锁在 Go 中通过 execve 之后不生效的问题

背景

man 2 fcntl

​ Record locks are not inherited by a child created via fork(2), but are preserved across an execve(2).

看到 fcntl 的介绍，我们想当然地认为 fcntl 的记录锁在 execve 之后都是能够保留的。

在我们使用 Go 来实现的时候，很快就发现了问题，请看如下代码：

package main import ( "fmt" "log" "os" "runtime" "syscall" "time" ) func main() { fmt.Println("Begin") fd, err := syscall.Open("lock", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0777) if err != nil { log.Printf("%s", err) return } ft := &syscall.Flock_t{ Type: syscall.F_WRLCK, } err = syscall.FcntlFlock(uintptr(fd), syscall.F_SETLK, ft) if err != nil { log.Printf("%s", err) return } fmt.Printf("Pid %d fd %d \n", os.Getpid(), fd) time.Sleep(5 * time.Second) argv := []string{"./test.sh"} syscall.Exec(argv[0], argv, []string{}) }

这段代码在 Linux 上，是无法把 fcntl 的锁传递给 test.sh 进程的。然而在 macOS 上很正常。

另外通过 C/Python 来实现，也是没有问题的。

#include <unistd.h> #include <fcntl.h> #include <stdio.h> #include <stdlib.h> int main() { printf("begin %d\n", getpid()); int fd = open("lock", O_WRONLY | O_CREAT | O_TRUNC , 0777); if (fd < 0 ) { printf("fail to open"); return -1; } printf("fd %d\n", fd); struct flock fl ; fl.l_type = F_WRLCK; fl.l_whence = SEEK_SET; fl.l_start = 0; fl.l_len = 0; int errno = fcntl(fd, F_SETLK, &fl); if( errno != 0) { printf("err %d", errno); return -1; } sleep(5); char *env[] = { NULL }; char *argv[] = {"./test.sh", NULL}; execve(argv[0], argv, env); return 0; }

所以问题是出在 Go 语言本身吗？

原因

在黄老板手写了一个内核模块深入分析后，发现内核在 exceve 时关闭了锁。阅读 Linux Kernel 源码后，终于发现真相。

我们来看下 exceve 系统调用的部分实现。

do_execveat_common 中：

struct files_struct *displaced; retval = unshare_files(&displaced); ... if (displaced) put_files_struct(displaced);

我们需要关注的是 displaced 这个变量。

unshare_files 调用了 unshare_fd:

/* * Helper to unshare the files of the current task. * We don't want to expose copy_files internals to * the exec layer of the kernel. */ int unshare_files(struct files_struct **displaced) { struct task_struct *task = current; struct files_struct *copy = NULL; int error; error = unshare_fd(CLONE_FILES, &copy); if (error || !copy) { *displaced = NULL; return error; } *displaced = task->files; task_lock(task); task->files = copy; task_unlock(task); return 0; }

unshare_fd:

/* * Unshare file descriptor table if it is being shared */ static int unshare_fd(unsigned long unshare_flags, struct files_struct **new_fdp) { struct files_struct *fd = current->files; int error = 0; if ((unshare_flags & CLONE_FILES) && (fd && atomic_read(&fd->count) > 1)) { *new_fdp = dup_fd(fd, &error); if (!*new_fdp) return error; } return 0; }

这里，当发现 fd 的引用计数大于 1 时，调用 dup_fd 复制一个新的 fdt 表。

之后在 put_files_struct 函数中 displaced 文件进行关闭操作。

void put_files_struct(struct files_struct *files) { if (atomic_dec_and_test(&files->count)) { struct fdtable *fdt = close_files(files); /* free the arrays if they are not embedded */ if (fdt != &files->fdtab) __free_fdtable(fdt); kmem_cache_free(files_cachep, files); } }

结论

所以在单线程环境中，fd 的引用计数等于 1，原来的 fdt 会被之后的进程继承。而在多线程环境下，旧的 fdt 会被替换并且关闭。

总之，多线程环境下，慎用 fcntl 记录锁。

当我们在 C 代码中加入线程后，就能发现 execve 之后 fcntl 锁没有保留。

#include <unistd.h> #include <fcntl.h> #include <stdio.h> #include <pthread.h> #include <stdlib.h> void thread(){ for(int i=0;i<=5;i++) { printf("this is thread %d\n", i); sleep(5); } } int main() { printf("begin %d\n", getpid()); int fd = open("lock", O_WRONLY | O_CREAT | O_TRUNC , 0777); if (fd < 0 ) { printf("fail to open"); return -1; } printf("fd %d\n", fd); struct flock fl ; fl.l_type = F_WRLCK; fl.l_whence = SEEK_SET; fl.l_start = 0; fl.l_len = 0; int errno = fcntl(fd, F_SETLK, &fl); if( errno != 0) { printf("err %d", errno); return -1; } pthread_t id; //线程的标识符,unsigned long int. int ret,i=0; ret = pthread_create(&id,NULL,(void *)thread,NULL); if(ret!=0) // 线程创建成功返回0 { printf("To thread failed\n"); exit(0); } sleep(5); char *env[] = { NULL }; char *argv[] = {"./test.sh", NULL}; execve(argv[0], argv, env); return 0; }