溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
??傳送文件描述符是高并發網絡服務編程的一種常見實現方式。Nebula 高性能通用網絡框架即采用了UNIX域套接字傳遞文件描述符設計和實現。本文詳細說明一下傳送文件描述符的應用。
??開發一個服務器程序，有較多的的程序設計范式可供選擇，不同范式有其自身的特點和實用范圍，明了不同范式的特性有助于我們服務器程序的開發。常見的TCP服務器程序設計范式有以下幾種：
??當系統負載較輕時，傳統的并發服務器程序模型就夠了。相對于傳統的每個客戶一次fork設計，預先創建一個進程池或線程池可以減少進程控制CPU時間，大約可減少10倍以上。
??某些實現允許多個子進程或線程阻塞在accept上，然而在另一些實現中，我們必須使用文件鎖、線程互斥鎖或其他類型的鎖來確保每次只有一個子進程或線程在accept。
??一般來講，所有子進程或線程都調用accept要比父進程或主線程調用accept后將描述字傳遞個子進程或線程來得快且簡單。
??Nebula框架是預先創建多進程，由Manager主進程accept后傳遞文件描述符到Worker子進程的服務模型（Nebula進程模型）。為什么不采用像nginx那樣多線程由子線程使用互斥鎖上鎖保護accept的服務模型？而且這種服務模型的實現比傳遞文件描述符來得還簡單一些。
??Nebula框架采用無鎖設計，進程之前完全不共享數據，不存在需要互斥訪問的地方。沒錯，會存在數據多副本問題，但這些多副本往往只是些配置數據，占用不了太大內存，與加鎖解鎖帶來的代碼復雜度及鎖開銷相比這點內存代價更劃算也更簡單。
??同一個Nebula服務的工作進程間不相互通信，采用進程和線程并無太大差異，之所以采用進程而不是線程的最重要考慮是Nebula是出于穩定性和容錯性考慮。Nebula是通用框架，完全業務無關，業務都是通過動態加載的方式或通過將Nebula鏈接進業務Server的方式來實現。Nebula框架無法預知業務代碼的質量，但可以保證在服務因業務代碼導致coredump或其他情況時，框架可以實時監控到并立刻拉起服務進程，最大程度保障服務可用性。
??決定Nebula采用傳遞文件描述符方式的最重要一點是：Nebula定位是高性能分布式服務集群解決方案的基礎通信框架，其設計更多要為構建分布式服務集群而考慮。集群不同服務節點之間通過TCP通信，而所有邏輯都是Worker進程負責，這意味著節點之間通信需要指定到Worker進程，而如果采用子進程競爭accept的方式無法保證指定的子進程獲得資源，那么第一個通信數據包將會路由錯誤。采用傳遞文件描述符方式可以很完美地解決這個問題，而且傳遞文件描述符也非常高效。
??文件描述符傳遞通過調用sendmsg()函數發送，調用recvmsg()函數接收：
#include <sys/types.h>
#include <sys/socket.h>
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);??這兩個函數與sendto和recvfrom函數相似，只不過可以傳輸更復雜的數據結構，不僅可以傳輸一般數據，還可以傳輸額外的數據，即文件描述符。下面來看結構體msghdr及其相關結構體 ：
struct msghdr {
void *msg_name; /* optional address */
socklen_t msg_namelen; /* size of address */
struct iovec *msg_iov; /* scatter/gather array */
size_t msg_iovlen; /* # elements in msg_iov */
void *msg_control; /* ancillary data, see below */
size_t msg_controllen; /* ancillary data buffer len */
int msg_flags; /* flags on received message */
};
/* iovec結構體 */
struct iovec {
void *iov_base; /* Starting address */
size_t iov_len; /* Number of bytes to transfer */
};
/* cmsghdr結構體 */
struct cmsghdr {
socklen_t cmsg_len; /* data byte count, including header */
int cmsg_level; /* originating protocol */
int cmsg_type; /* protocol-specific type */
/* followed by unsigned char cmsg_data[]; */
};??msghdr結構成員說明：
??為了對齊，可能存在一些填充字節，跟不同系統的實現有關控制信息的數據部分，是直接存儲在cmsghdr結構體的cmsg_type之后的。但中間可能有一些由于對齊產生的填充字節，由于這些填充數據的存在，對于這些控制數據的訪問，必須使用Linux提供的一些專用宏來完成：
#include <sys/socket.h>
/* 返回msgh所指向的msghdr類型的緩沖區中的第一個cmsghdr結構體的指針。*/
struct cmsghdr *CMSG_FIRSTHDR(struct msghdr *msgh);
/* 返回傳入的cmsghdr類型的指針的下一個cmsghdr結構體的指針。 */
struct cmsghdr *CMSG_NXTHDR(struct msghdr *msgh, struct cmsghdr *cmsg);
/* 根據傳入的length大小,返回一個包含了添加對齊作用的填充數據后的大小。 */
size_t CMSG_ALIGN(size_t length);
/* 傳入的參數length指的是一個控制信息元素(即一個cmsghdr結構體)后面數據部分的字節數,返回的是這個控制信息的總的字節數,即包含了頭部(即cmsghdr各成員)、數據部分和填充數據的總和。*/
size_t CMSG_SPACE(size_t length);
/* 根據傳入的cmsghdr指針參數，返回其后面數據部分的指針。*/
size_t CMSG_LEN(size_t length);
/* 傳入的參數是一個控制信息中的數據部分的大小，返回的是這個根據這個數據部分大小，需要配置的cmsghdr結構體中cmsg_len成員的值。這個大小將為對齊添加的填充數據也包含在內。*/
unsigned char *CMSG_DATA(struct cmsghdr *cmsg);??sendmsg提供了可以傳遞控制信息的功能，要實現的傳遞描述符這一功能必須要用到這個控制信息。在msghdr變量的cmsghdr成員中，由控制頭cmsg_level和cmsg_type來設置傳遞文件描述符這一屬性，并將要傳遞的文件描述符作為數據部分，保存在cmsghdr變量的后面。這樣就可以實現傳遞文件描述符這一功能，這種情況是不需要使用msg_iov來傳遞數據的。
??具體地說，為msghdr的成員msg_control分配一個cmsghdr的空間，將該cmsghdr結構的cmsg_level設置為SOL_SOCKET，cmsg_type設置為SCM_RIGHTS，并將要傳遞的文件描述符作為數據部分，調用sendmsg即可。其中SCM表示socket-level control message，SCM_RIGHTS表示我們要傳遞訪問權限。
??跟發送部分一樣，為控制信息配置好屬性，并在其后分配一個文件描述符的數據部分后，在成功調用recvmsg后，控制信息的數據部分就是在接收進程中的新的文件描述符了，接收進程可直接對該文件描述符進行操作。
??文件描述符傳遞并不是將文件描述符數字傳遞，而是文件描述符對應數據結構。在主進程accept的到的文件描述符7傳遞到子進程后文件描述符有可能是7，更有可能是7以外的其他數值，但無論是什么數值并不重要，重要的是傳遞之后的連接跟傳遞之前的連接是同一個連接。
??通常在完成文件描述符傳遞后，接收進程接管文件描述符，發送進程則應調用close關閉已傳遞的文件描述符。發送進程關閉描述符并不造成關閉該文件或設備，因為該描述符對應的文件仍被視為由接收者進程打開（即使接收進程尚未接收到該描述符）。
??文件描述符傳遞可經由基于STREAMS的管道，也可經由UNIX域套接字。兩種方式在《UNIX網絡編程》中均有描述，Nebula采用的UNIX域套接字傳遞文件描述符。
??創建用于傳遞文件描述符的UNIX域套接字用到socketpair函數：
#include <sys/types.h>
#include <sys/socket.h>
int socketpair(int d, int type, int protocol, int sv[2]); ??傳入的參數sv為一個整型數組，有兩個元素。當調用成功后，這個數組的兩個元素即為2個文件描述符。一對連接起來的Unix匿名域套接字就建立起來了，它們就像一個全雙工的管道，每一端都既可讀也可寫。
??Nebula框架的文件描述符屬于SocketChannel的基本屬性，文件描述符傳遞方法是SocketChannel的靜態方法。
文件描述符傳遞方法聲明：
static int SendChannelFd(int iSocketFd, int iSendFd, int iCodecType, std::shared_ptr<NetLogger> pLogger);
static int RecvChannelFd(int iSocketFd, int& iRecvFd, int& iCodecType, std::shared_ptr<NetLogger> pLogger);文件描述符發送方法實現：
/**
* @brief 發送文件描述符
* @param iSocketFd 由socketpair()創建的UNIX域套接字，用于傳遞文件描述符
* @param iSendFd 待發送的文件描述符
* @param iCodecType 通信通道編解碼類型
* @param pLogger 日志類指針
* @return errno 錯誤碼
*/
int SocketChannel::SendChannelFd(int iSocketFd, int iSendFd, int iCodecType, std::shared_ptr<NetLogger> pLogger)
{
ssize_t n;
struct iovec iov[1];
struct msghdr msg;
tagChannelCtx stCh;
int iError = 0;
stCh.iFd = iSendFd;
stCh.iCodecType = iCodecType;
union
{
struct cmsghdr cm;
char space[CMSG_SPACE(sizeof(int))];
} cmsg;
if (stCh.iFd == -1)
{
msg.msg_control = NULL;
msg.msg_controllen = 0;
}
else
{
msg.msg_control = (caddr_t) &cmsg;
msg.msg_controllen = sizeof(cmsg);
memset(&cmsg, 0, sizeof(cmsg));
cmsg.cm.cmsg_len = CMSG_LEN(sizeof(int));
cmsg.cm.cmsg_level = SOL_SOCKET;
cmsg.cm.cmsg_type = SCM_RIGHTS;
*(int *) CMSG_DATA(&cmsg.cm) = stCh.iFd;
}
msg.msg_flags = 0;
iov[0].iov_base = (char*)&stCh;
iov[0].iov_len = sizeof(tagChannelCtx);
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_iov = iov;
msg.msg_iovlen = 1;
n = sendmsg(iSocketFd, &msg, 0);
if (n == -1)
{
pLogger->WriteLog(neb::Logger::ERROR, __FILE__, __LINE__, __FUNCTION__, "sendmsg() failed, errno %d", errno);
iError = (errno == 0) ? ERR_TRANSFER_FD : errno;
return(iError);
}
return(ERR_OK);
}文件描述符接收方法實現：
/**
* @brief 接收文件描述符
* @param iSocketFd 由socketpair()創建的UNIX域套接字，用于傳遞文件描述符
* @param iRecvFd 接收到的文件描述符
* @param iCodecType 接收到的通信通道編解碼類型
* @param pLogger 日志類指針
* @return errno 錯誤碼
*/
int SocketChannel::RecvChannelFd(int iSocketFd, int& iRecvFd, int& iCodecType, std::shared_ptr<NetLogger> pLogger)
{
ssize_t n;
struct iovec iov[1];
struct msghdr msg;
tagChannelCtx stCh;
int iError = 0;
union {
struct cmsghdr cm;
char space[CMSG_SPACE(sizeof(int))];
} cmsg;
iov[0].iov_base = (char*)&stCh;
iov[0].iov_len = sizeof(tagChannelCtx);
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_iov = iov;
msg.msg_iovlen = 1;
msg.msg_control = (caddr_t) &cmsg;
msg.msg_controllen = sizeof(cmsg);
n = recvmsg(iSocketFd, &msg, 0);
if (n == -1) {
pLogger->WriteLog(neb::Logger::ERROR, __FILE__, __LINE__, __FUNCTION__, "recvmsg() failed, errno %d", errno);
iError = (errno == 0) ? ERR_TRANSFER_FD : errno;
return(iError);
}
if (n == 0) {
pLogger->WriteLog(neb::Logger::ERROR, __FILE__, __LINE__, __FUNCTION__, "recvmsg() return zero, errno %d", errno);
iError = (errno == 0) ? ERR_TRANSFER_FD : errno;
return(ERR_CHANNEL_EOF);
}
if ((size_t) n < sizeof(tagChannelCtx))
{
pLogger->WriteLog(neb::Logger::ERROR, __FILE__, __LINE__, __FUNCTION__, "rrecvmsg() returned not enough data: %z, errno %d", n, errno);
iError = (errno == 0) ? ERR_TRANSFER_FD : errno;
return(iError);
}
if (cmsg.cm.cmsg_len < (socklen_t) CMSG_LEN(sizeof(int)))
{
pLogger->WriteLog(neb::Logger::ERROR, __FILE__, __LINE__, __FUNCTION__, "recvmsg() returned too small ancillary data");
iError = (errno == 0) ? ERR_TRANSFER_FD : errno;
return(iError);
}
if (cmsg.cm.cmsg_level != SOL_SOCKET || cmsg.cm.cmsg_type != SCM_RIGHTS)
{
pLogger->WriteLog(neb::Logger::ERROR, __FILE__, __LINE__, __FUNCTION__,
"recvmsg() returned invalid ancillary data level %d or type %d", cmsg.cm.cmsg_level, cmsg.cm.cmsg_type);
iError = (errno == 0) ? ERR_TRANSFER_FD : errno;
return(iError);
}
stCh.iFd = *(int *) CMSG_DATA(&cmsg.cm);
if (msg.msg_flags & (MSG_TRUNC|MSG_CTRUNC))
{
pLogger->WriteLog(neb::Logger::ERROR, __FILE__, __LINE__, __FUNCTION__, "recvmsg() truncated data");
iError = (errno == 0) ? ERR_TRANSFER_FD : errno;
return(iError);
}
iRecvFd = stCh.iFd;
iCodecType = stCh.iCodecType;
return(ERR_OK);
}Manager進程的void Manager::CreateWorker()方法創建用于傳遞文件描述符的UNIX域套接字：
int iControlFds[2];
int iDataFds[2];
if (socketpair(PF_UNIX, SOCK_STREAM, 0, iControlFds) < 0)
{
LOG4_ERROR("error %d: %s", errno, strerror_r(errno, m_szErrBuff, 1024));
}
if (socketpair(PF_UNIX, SOCK_STREAM, 0, iDataFds) < 0)
{
LOG4_ERROR("error %d: %s", errno, strerror_r(errno, m_szErrBuff, 1024));
}Manager進程發送文件描述符：
int iCodec = m_stManagerInfo.eCodec; // 將編解碼方式和文件描述符一同發送給Worker進程
int iErrno = SocketChannel::SendChannelFd(worker_pid_fd.second, iAcceptFd, iCodec, m_pLogger);
if (iErrno == 0)
{
AddWorkerLoad(worker_pid_fd.first);
}
else
{
LOG4_ERROR("error %d: %s", iErrno, strerror_r(iErrno, m_szErrBuff, 1024));
}
close(iAcceptFd); // 發送完畢，關閉文件描述符Worker進程接收文件描述符：
``` C++
int iAcceptFd = -1;
int iCodec = 0; // 這里的編解碼方式在RecvChannelFd方法中獲得
int iErrno = SocketChannel::RecvChannelFd(m_stWorkerInfo.iManagerDataFd, iAcceptFd, iCodec, m_pLogger);
??至此，Nebula框架的文件描述符傳遞分享完畢，下面再看看nginx中的文件描述符傳遞實現。
### 6. Nginx文件描述符傳遞代碼實現
??Nginx的文件描述符傳遞代碼在os/unix/ngx_channel.c文件中。
nginx中發送文件描述符代碼：
ngx_int_t
ngx_write_channel(ngx_socket_t s, ngx_channel_t ch, size_t size,
ngx_log_t log)
{
ssize_t n;
ngx_err_t err;
struct iovec iov[1];
struct msghdr msg;
#if (NGX_HAVE_MSGHDR_MSG_CONTROL)
union {
struct cmsghdr cm;
char space[CMSG_SPACE(sizeof(int))];
} cmsg;
if (ch->fd == -1) {
msg.msg_control = NULL;
msg.msg_controllen = 0;
} else {
msg.msg_control = (caddr_t) &cmsg;
msg.msg_controllen = sizeof(cmsg);
ngx_memzero(&cmsg, sizeof(cmsg));
cmsg.cm.cmsg_len = CMSG_LEN(sizeof(int));
cmsg.cm.cmsg_level = SOL_SOCKET;
cmsg.cm.cmsg_type = SCM_RIGHTS;
/*
* We have to use ngx_memcpy() instead of simple
* *(int *) CMSG_DATA(&cmsg.cm) = ch->fd;
* because some gcc 4.4 with -O2/3/s optimization issues the warning:
* dereferencing type-punned pointer will break strict-aliasing rules
*
* Fortunately, gcc with -O1 compiles this ngx_memcpy()
* in the same simple assignment as in the code above
*/
ngx_memcpy(CMSG_DATA(&cmsg.cm), &ch->fd, sizeof(int));
}
msg.msg_flags = 0;#else
if (ch->fd == -1) {
msg.msg_accrights = NULL;
msg.msg_accrightslen = 0;
} else {
msg.msg_accrights = (caddr_t) &ch->fd;
msg.msg_accrightslen = sizeof(int);
}#endif
iov[0].iov_base = (char *) ch;
iov[0].iov_len = size;
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_iov = iov;
msg.msg_iovlen = 1;
n = sendmsg(s, &msg, 0);
if (n == -1) {
err = ngx_errno;
if (err == NGX_EAGAIN) {
return NGX_AGAIN;
}
ngx_log_error(NGX_LOG_ALERT, log, err, "sendmsg() failed");
return NGX_ERROR;
}
return NGX_OK;}
nginx中接收文件描述符代碼：
ngx_int_t
ngx_read_channel(ngx_socket_t s, ngx_channel_t ch, size_t size, ngx_log_t log)
{
ssize_t n;
ngx_err_t err;
struct iovec iov[1];
struct msghdr msg;
#if (NGX_HAVE_MSGHDR_MSG_CONTROL)
union {
struct cmsghdr cm;
char space[CMSG_SPACE(sizeof(int))];
} cmsg;
#else
int fd;
#endif
iov[0].iov_base = (char *) ch;
iov[0].iov_len = size;
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_iov = iov;
msg.msg_iovlen = 1;#if (NGX_HAVE_MSGHDR_MSG_CONTROL)
msg.msg_control = (caddr_t) &cmsg;
msg.msg_controllen = sizeof(cmsg);
#else
msg.msg_accrights = (caddr_t) &fd;
msg.msg_accrightslen = sizeof(int);
#endif
n = recvmsg(s, &msg, 0);
if (n == -1) {
err = ngx_errno;
if (err == NGX_EAGAIN) {
return NGX_AGAIN;
}
ngx_log_error(NGX_LOG_ALERT, log, err, "recvmsg() failed");
return NGX_ERROR;
}
if (n == 0) {
ngx_log_debug0(NGX_LOG_DEBUG_CORE, log, 0, "recvmsg() returned zero");
return NGX_ERROR;
}
if ((size_t) n < sizeof(ngx_channel_t)) {
ngx_log_error(NGX_LOG_ALERT, log, 0,
"recvmsg() returned not enough data: %z", n);
return NGX_ERROR;
}#if (NGX_HAVE_MSGHDR_MSG_CONTROL)
if (ch->command == NGX_CMD_OPEN_CHANNEL) {
if (cmsg.cm.cmsg_len < (socklen_t) CMSG_LEN(sizeof(int))) {
ngx_log_error(NGX_LOG_ALERT, log, 0,
"recvmsg() returned too small ancillary data");
return NGX_ERROR;
}
if (cmsg.cm.cmsg_level != SOL_SOCKET || cmsg.cm.cmsg_type != SCM_RIGHTS)
{
ngx_log_error(NGX_LOG_ALERT, log, 0,
"recvmsg() returned invalid ancillary data "
"level %d or type %d",
cmsg.cm.cmsg_level, cmsg.cm.cmsg_type);
return NGX_ERROR;
}
/* ch->fd = *(int *) CMSG_DATA(&cmsg.cm); */
ngx_memcpy(&ch->fd, CMSG_DATA(&cmsg.cm), sizeof(int));
}
if (msg.msg_flags & (MSG_TRUNC|MSG_CTRUNC)) {
ngx_log_error(NGX_LOG_ALERT, log, 0,
"recvmsg() truncated data");
}#else
if (ch->command == NGX_CMD_OPEN_CHANNEL) {
if (msg.msg_accrightslen != sizeof(int)) {
ngx_log_error(NGX_LOG_ALERT, log, 0,
"recvmsg() returned no ancillary data");
return NGX_ERROR;
}
ch->fd = fd;
}#endif
return n;}
??__Nebula框架系列技術分享__ 之 《通過UNIX域套接字傳遞文件描述符》。 如果覺得這篇文章對你有用，如果覺得Nebula框架還可以，幫忙到Nebula的[__Github__](https://github.com/Bwar/Nebula)或[__碼云__](https://gitee.com/Bwar/Nebula)給個star，謝謝。Nebula不僅是一個框架，還提供了一系列基于這個框架的應用，目標是打造一個高性能分布式服務集群解決方案。
參考資料：
* 《UNIX網絡編程》
* 《UNIX環境高級編程》
* [進程間傳遞文件描述符](https://pureage.info/2015/03/19/passing-file-descriptors.html)
* [linux網絡編程之socket（十六）：通過UNIX域套接字傳遞描述符和 sendmsg/recvmsg 函數](https://blog.csdn.net/jnu_simba/article/details/9079627)免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
