聊聊跨進程共享內存的內部工作原理
大家好，我是飛哥！
在 Linux 系統的進程虛擬內存中，一個重要的特性就是不同進程的地址空間是隔離的。A 進程的地址 0x4000 和 B 進程的 0x4000 之間沒有任何關系。這樣確確實實是讓各個進程的運行時互相之間的影響降到了最低。某個進程有 bug 也只能自己崩潰，不會影響其它進程的運行。
但是有時候我們想要跨進程傳遞一些數據。因為進程虛擬內存地址是隔離的。所以目前業界最常用的做法是讓進程之間通過 127.0.0.1 或者是 Unix Domain Socket 等本機網絡手段進行數據的傳輸。這個方案在傳輸的數據量較小的時候工作是很不錯的。
但如果進程間想共享的數據特別大，比如說幾個 GB，那如果使用網絡 IO 方案的話，就會涉及到大量的內存拷貝的開銷，導致比較低的程序性能。這是可以采用進程間共享內存的方法來在通信時避免內存拷貝。
那么問題來了，不同進程之間的虛擬地址是隔離的，共享內存又是如何突破這個限制的呢？我們今天就來深入地了解下共享內存的內部工作原理。
一、共享內存的使用方式
共享內存發送方進程的開發基本過程是調用 memfd_create 創建一個內存文件。然后通過 mmap 系統調用為這個內存文件申請一塊共享內存。然后這個內存文件就可以寫入數據了。最后把這個文件的句柄通過 Unix Domain Socket 的方式給接收方進程發送過去。
下面是發送方的核心代碼。
int main(int argc, char **argv) {
// 創建內存文件
fd = memfd_create("Server memfd", ...);
// 為內存文件申請 MAP_SHARED 類型的內存
shm = mmap(NULL, shm_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
// 向共享內存中寫入數據
sprintf(shm, "這段內容是保存在共享內存里的，接收方和發送方都能根據自己的fd訪問到這塊內容");
// 把共享內存文件的句柄給接收方進程發送過去
struct msghdr msgh;
*((int *) CMSG_DATA(CMSG_FIRSTHDR(&msgh))) = fd;
sendmsg(conn, &msgh, 0);
......
}共享內存接收方的工作過程是先用 Unix Domain Socket 連接上服務器，然后使用 recvmsg 就可以收到發送方發送過來的文件句柄。
int main(int argc, char **argv) {
// 通過 Unix Domain Socket 連接發送方
connect(conn, (struct sockaddr *)&address, sizeof(struct sockaddr_un));
// 通過連接取出發送方發送過來的內存文件句柄
int size = recvmsg(conn, &msgh, 0);
fd = *((int *) CMSG_DATA(cmsgh));
// 讀取共享文件中的內容
shm = mmap(NULL, shm_size, PROT_READ, MAP_PRIVATE, fd, 0);
printf("共享內存中的文件內容是: %s\n", shm);
......
}這樣這兩個進程都各自有一個文件句柄，在底層上是指向同一個內存文件的。這樣就實現了發送方和接收方之間的內存文件共享了。
圖片
但我們上面介紹的是開發基本過程。按照我們開發內功修煉公眾號的風格，這還不算完，我們是要把它最底層的原理真正的弄通透才算的。所以接下來我們再深入地分析 memfd_create、 mmap、以及 Unix Domain socket sendmsg 和 recvmsg 的底層工作原理，來看看它們是如何配合來實現跨進程共享內存的。
二、共享內存文件原理
在發送方發送文件之前，需要先通過 memfd_create 來創建一個內存文件，然后再使用 mmap 為其分配內存。
2.1 創建內存文件
其中 memfd_create 函數是一個系統調用。內核中它的主要邏輯有兩個，一是調用 get_unused_fd_flags 申請一個沒使用過的文件句柄，二是調用 shmem_file_setup 創建一個共享內存文件。
圖片
我們來看 memfd_create 的源碼。
// file:mm/memfd.c
SYSCALL_DEFINE2(memfd_create,
const char __user *, uname,
unsigned int, flags)
{
...
// 申請一個未使用過的文件句柄
fd = get_unused_fd_flags((flags & MFD_CLOEXEC) ? O_CLOEXEC : 0);
// 創建一個共享內存的文件
file = shmem_file_setup(name, 0, VM_NORESERVE);
fd_install(fd, file);
return fd;
}其中在 shmem_file_setup 函數中又調用了 __shmem_file_setup。
// file:mm/shmem.c
static struct file *__shmem_file_setup(struct vfsmount *mnt, const char *name, ...)
{
...
// 申請一個 inode
inode = shmem_get_inode(mnt->mnt_sb, NULL, S_IFREG | S_IRWXUGO, 0,
flags);
inode->i_flags |= i_flags;
inode->i_size = size;
...
// 創建一個文件
res = alloc_file_pseudo(inode, mnt, name, O_RDWR,
&shmem_file_operations);
return res;
}我們都知道磁盤文件在內核的實現中是由 inode 和 struct file 對象一起組成的。其實共享內存文件也一樣，__shmem_file_setup 中就是先申請了一個 inode，然后再調用 alloc_file_pseudo 創建一個文件。值得注意的是，這個文件并非是磁盤上的文件，而只是在內存里的。
2.2 mmap申請內存
mmap 也是一個系統調用，注意我們在開篇處調用它的時候傳入的第三個 flag 參數是 MAP_SHARED。這表示的是要通過 mmap 申請一塊跨進程可共享的內存出來。mmap 的實現入口在 arch/x86/kernel/sys_x86_64.c
//file:arch/x86/kernel/sys_x86_64.c
SYSCALL_DEFINE6(mmap, unsigned long, addr, ...)
{
return ksys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);
}接下來的這個函數的調用鏈路如下
SYSCALL_DEFINE6(mmap
-> ksys_mmap_pgoff
---> vm_mmap_pgoff
------> do_mmap_pgoff
--------> do_mmap在 do_mmap 函數中，對輸入的 MAP_SHARED 進行了處理。
//file:mm/mmap.c
unsigned long do_mmap(struct file *file, unsigned long addr,
unsigned long len, unsigned long prot,
unsigned long flags, vm_flags_t vm_flags,
unsigned long pgoff, unsigned long *populate,
struct list_head *uf)
{
struct mm_struct * mm = current->mm;
...
// 如果包含 MAP_SHARED，則對要申請的虛擬內存設置一個 VM_SHARED
switch (flags & MAP_TYPE) {
case MAP_SHARED:
case MAP_SHARED_VALIDATE:
vm_flags |= VM_SHARED | VM_MAYSHARE;
...
}
...
addr = mmap_region(file, addr, len, vm_flags, pgoff, uf);
......
}如果 flag 包含了 MAP_SHARED，則對要申請的虛擬內存設置一個 VM_SHARED。該標記指明的是要申請一個可以跨進程共享的內存塊。接下來進入 mmap_region 中申請虛擬內存。
//file:mm/mmap.c
unsigned long mmap_region(struct file *file, ...)
{
struct mm_struct *mm = current->mm;
......
// 申請虛擬內存vma
vma = vm_area_alloc(mm);
// vma初始化
vma->vm_start = addr;
vma->vm_end = addr + len;
vma->vm_flags = vm_flags;
vma->vm_page_prot = vm_get_page_prot(vm_flags);
vma->vm_pgoff = pgoff;
......
// 加入到進程的虛擬內存 vma 鏈表中來
vma_link(mm, vma, prev, rb_link, rb_parent);
}進程的虛擬內存地址空間在內核底層中就是由這樣一個個的 vma 來組成的。每一個 vma 都聲明的是進程虛擬地址中的某一段地址范圍已經分配出去了。在 mmap_region 函數中申請了 vma，并在內核中將其管理了起來。
這里注意我們在申請共享內存的時候，給 vma 是帶了 VM_SHARED 標記的。帶了這個標記的 vma和普通的虛擬內存不一樣。后面在發生缺頁中斷申請物理內存的時候，在不同的進程間是可以對應到同一塊物理內存的。所以可以實現進程間的共享。
圖片
所以真正讓進程之間可以共享內存的是這個帶 VM_SHARED 的 vma。
三、發送方發送文件句柄
發送方在使用 memfd_create 創建出來內存文件，并用 mmap 為其申請可跨進程共享的內存后。接著就可以通過 Unix Domain Socket 中對應的 sendmsg 方法將這個共享內存文件的句柄發送出來。如下是發送的代碼示例。
static void send_fd(int conn, int fd) {
struct msghdr msgh;
struct iovec iov;
...
// 把文件句柄放到消息中來
*((int *) CMSG_DATA(CMSG_FIRSTHDR(&msgh))) = fd;
// 發送出去
sendmsg(conn, &msgh, 0);
}sendmsg 又是一個內核提供的系統調用，它位于 net/socket.c 文件中。
//file:net/socket.c
SYSCALL_DEFINE3(sendmsg, int, fd, struct user_msghdr __user *, msg, unsigned int, flags)
{
return __sys_sendmsg(fd, msg, flags, true);
}該函數的調用路徑如下
SYSCALL_DEFINE3(sendmsg, ...)
-> __sys_sendmsg
---> ___sys_sendmsg
-----> ____sys_sendmsg
-------> sock_sendmsg
---------> sock_sendmsg_nosec
-----------> unix_stream_sendmsg在 unix_stream_sendmsg 中執行了真正的發送。
//file:net/unix/af_unix.c
static int unix_stream_sendmsg(struct socket *sock, struct msghdr *msg, ...)
{
// 把文件描述符指向的文件信息復制到 scm_cookie 中
struct scm_cookie scm;
scm_send(sock, msg, &scm, false);
// 不斷構建數據包發送，直到發送完畢
while (sent < len) {
// 申請一塊緩存區
skb = sock_alloc_send_pskb(sk, size - data_len, data_len,
msg->msg_flags & MSG_DONTWAIT, &err,
get_order(UNIX_SKB_FRAGS_SZ));
// 拷貝數據到 skb
err = unix_scm_to_skb(&scm, skb, !fds_sent);
err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, size);
// 直接把 skb 放到對端的接收隊列中
skb_queue_tail(&other->sk_receive_queue, skb);
//發送完畢回調
other->sk_data_ready(other);
sent += size;
...
}
}在 unix_stream_sendmsg 中申請了個 skb 緩存區，然后把要發送的文件句柄等數據都塞到里面，最后調用 skb_queue_tail 直接把 skb 放到 Unix Domain Socket 連接另一端的接收隊列中了。
這里注意文件句柄只有在當前進程內才是有意義的。如果直接發送 fd 出去，接收方是沒有辦法使用的。所以在 scm_send 函數中，重要的邏輯是把 fd 對應的 struct file 的指針給找了出來，放到待發送的數據里面了。只有 file 這種內核級的對象接收方才能使用。
scm_send
-> __scm_send
---> scm_fp_copy在 scm_fp_copy 中根據 fd 把 file 給找了出來。它的指針會被放到發送數據中
//file:net/core/scm.c
static int scm_fp_copy(struct cmsghdr *cmsg, struct scm_fp_list **fplp)
{
...
//把每一個要發送的 fd 對應的 file 給找出來
for (i=0; i< num; i++)
{
int fd = fdp[i];
struct file *file;
if (fd < 0 || !(file = fget_raw(fd)))
return -EBADF;
*fpp++ = file;
fpl->count++;
}
}四、接收方接收文件
接下來接收方就可以通過 recvmsg 來接收發送方發送過來的文件了。recvmsg 系統會調用到 unix_stream_read_generic 中，然后在這個函數中把 skb 給取出來。
圖片
下面是接收函數核心 unix_stream_read_generic 的源碼。
//file:net/unix/af_unix.c
static int unix_stream_read_generic(struct unix_stream_read_state *state,
bool freezable)
{
do {
// 拿出一個 skb
last = skb = skb_peek(&sk->sk_receive_queue);
...
}
...
if (state->msg)
scm_recv(sock, state->msg, &scm, flags);
return copied ? : err;
}在 skb 拿出來后，還需要調用 scm_recv 來把 skb 中包含的文件給找出來。在 scm_recv 中調用 scm_detach_fds。
//file:net/core/scm.c
void scm_detach_fds(struct msghdr *msg, struct scm_cookie *scm)
{
for (i = 0; i < fdmax; i++) {
err = receive_fd_user(scm->fp->fp[i], cmsg_data + i, o_flags);
if (err < 0)
break;
}
...
}在 scm->fp->fp[i] 中包含的是發送方發送過來的 struct file 指針。這樣文件就取出來了。當然 struct file 是個內核態的對象，用戶沒有辦法使用。所以還需要再為其在新的進程中申請一個文件句柄，然后返回。本文來自公眾號「開發內功修煉」。
//file:fs/file.c
int __receive_fd(struct file *file, int __user *ufd, unsigned int o_flags)
{
//申請一個新的文件描述符
new_fd = get_unused_fd_flags(o_flags);
...
//關聯文件
fd_install(new_fd, get_file(file));
return new_fd;
}五、總結
共享內存發送方進程的開發過程基本分 memfd_create 創建內存文件、mmap 申請共享內存、Unix Domain Socket 發送文件句柄三步。
- 第一步，memfd_create 系統調用的主要邏輯有兩個，一是調用 get_unused_fd_flags 申請一個沒使用過的文件句柄，二是調用 shmem_file_setup 創建一個共享內存文件。
- 第二步，mmap 系統調用在調用它的時候傳入的第三個 flag 參數是 MAP_SHARED，該參數是申請一塊跨進程可共享訪問的物理內存。
- 第三步，接著通過 Unix Domain Socket 中對應的 sendmsg 方法將這個共享內存文件的句柄發送出去。在發送時，把文件句柄對應的 struct file 指針找到并放到要封裝的 skb 數據包中了。
接收方進程的主要實現原理是 recvmsg 系統調用。在這個系統調用中，內核會把發送方發送過來的 struct file 指針取出來，然后再在當前進程下為其申請一個新的文件句柄。這個文件句柄返回給用戶進程后，用戶進程就可以用它來和另外一個進程共享地訪問同一塊內存了。
總體來看，共享內存本質上共享的是內核對象 struct file，通過在不同的進程之間使用同一個 struct file 來實現的共享。當然也得需要在虛擬內存對象 vma 帶上 VM_SHARED 標記來支持。
