sendmsg(struct proc * p,struct sendmsg_args * uap,int * retval)
{
struct msghdr msg;
struct iovec aiov[UIO_SMALLOV],*iov;
int error;

/**
*一個有8個元素(UIO_SMALLIOV)的iovec數組從棧中自動分配。
*如果分配的數組不夠大，sendmsg將調用MALLOC分配更大的數組。如果進程指定的數組單元大於1024(UIO_MAXIOV),則返回EMSGSIZE。
*copyin將iovec數組從用戶空間複製到棧中的數組或一個更大的動態分配的數組中。
*這種技術避免了調用malloc帶來的高代價，因為大多數情況下，數組的單元數小於等於8
*/

//將msg數據從用戶空間複製到內核空間
if(error = copyin(uap->msg,(caddr_t)&msg,sizeof(msg))){
return (error);
}

if((u_int)msg.msg_iovlen >= UIO_SMALLIOV){
if((u_int)msg.msg_iovlen >= UIO_MAXIOV){
return (EMSGSIZE);
}

MALLOC(iov,struct iovec *,sizeof(struct iovec)*(u_int)msg.msg_iovlen,M_IOV,M_WAITOK);
}else{
iov = aiov;
}

if(msg.msg_iovlen && (error = copyin((caddr_t)msg.msg_iov,(caddr_t)iov,(unsigned)(msg.msg_iovlen * sizeof(struct iovec))))){
goto done;
}
msg.msg_iov = iov;

//如果sendit返回，則表明數據已經發送給相應的協議或出現差錯
error = sendit(p,uap->s,&msg,uap->flags,retval);
done:
if(iov != aiov){
FREE(iov,M_IOV);
}

if(error = getsock(p->p_fd,s,&fp)){
return error;
}

/**
*初始化uio結構，並將應用層的輸出緩存中的數據收集到內核緩存中
*/
auio.uio_iov = mp->msg_iov;
auio.uio_iovcnt = mp->msg_iovlen;
auio.uio_segflg = UIO_USERSPACE;
auio.uio_rw = UIO_WRITE;
auio.uio_procp = p;
auio.uio_offset = 0;
auio.uio_resid = 0;

iov = mp->msg_iov;

/**
*將傳送的數據的長度通過一個for循環來計算
*/
for(i = 0;i < mp->msg_iovlen;i++,iov++){
/**
*保證緩存的長度非負
*/
if(iov->iov_len < 0){ return (EINVAL); } /** *保證uio_resid不溢出，因為uio_resid是一個**有符號的**整數，且iov_len要求非負 */ if((auio.uio_resid += iov->iov_len) < 0){ return (EINVAL); } } /** *如果進程提供了地址和控制信息，則sockargs將地址和控制信息複製到內核緩存中 */ if(mp->msg_name){//如果進程提供了地址
//將地址複製到內核中
if(error = sockargs(&to,mp->msg_name,mp->msg_namelen,MT_SONAME)){
return (error);
}
}else{
top = 0;
}

if(mp->msg_control){//如果進程提供了控制信息
if(mp->msg_controllen < sizeof(struct cmsghdr)){ error = EINVAL; goto bad;; } //將控制信息複製到內核中 if(error = sockargs(&control,mp->msg_control,mp->msg_controllen,MT_CONTROL)){
goto bad;
}
}else{
control = 0;
}

/**
*發送數據和清除緩存
*/

len = auio.uio_resid;//為了防止sosend不接受所有數據而無法計算傳送的位元組數，將uio_resid的值保存在len中

//將socket、目的地址、uio結構(包含了要發送的數據)、控制信息和標誌全部傳給函數sosend
if(error = sosend((struct socket *)fp->f_data,to,&auio,(struct mbuf*)0,control,fkags)){
if(auio.uio_resid != len && (error == ERESTART || error == EINTR || error == EWOULDBLOCK)){
error = 0;
}

if(error == EPIPE){
psignal(p,SIGPIPE);
}
}

if(0 == error){
/**
*如果沒有差錯出現(或差錯被丟棄),則計算傳送的位元組數，並將其保存在*retsize中。
*如果sendit返回0，syscall返回*retsize給進程而不是返回差錯代碼
*/
*retsize = len - auio.uio_resid;
}

bad:
//釋放包含目的地址的緩存。
if(to){
m_freem(to);
}

struct proc * p = curproc;
struct mbuf **mp;
struct mbuf * m;
long space,len,resid;
int clen = 0,error,s,dontroute,mlen;

/**
* 如果sosendallatonce等於true(任何設置了PR_ATOMIC的協議)或數據已經通過top中的mbuf鏈傳送給sosend,則將設置atomic。這個標誌[控制數據是作為一個mbuf鏈還是作為獨立的mbuf傳送給協議].
*/

int automic = sosendallatonce(so) || top;

/**
*resid等於iovec緩存中的數據位元組數或top中的mbuf鏈中的數據位元組數
*/
if(uio){
resid = uio->uio_resid;
}else{
resid = top->m_pkthdr.len;
}

if(resid < 0){ return (EINVAL); } /** *如果僅僅要求對這個報文不通過路由表進行路由選擇，則設置dontroute */ dontroute = (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 && (so->so_proto->pr_flags & PR_ATOMIC);
p->p_stats->p_ru.ru_msgsnd++;

if(control){
/**
* clen等於在可選的控制緩存中的位元組數
*/
clen = control->m_len;
}

#define snderr(errno) {error = errno;splx(s);goto release;}

/**
*sosend的主循環從restart開始，在循環的開始調用sblock給發送緩存加鎖。通過加鎖確保多個進程按序互斥訪問socket緩存
*/
restart:
if(error = sblock(&so->so_snd,SBLOCKWAIT(flags)))
{
goto out;
}

/**
*主循環直到[將所有數據都傳送給協議層](即resid = 0)時才會退出
*/
do{

/**
* 等待發送緩存有空閑空間
*/

s = splnet;

/**
* 如果Socket輸出被禁止，即TCP連接的寫通道已經關閉，則返回EPIPE
*/
if(so->so_state & SS_CANTSENDMORE){
snderr(EPIPE);
}

/**
* 如果Socket正處於差錯狀態(例如，前一個數據報可能已經產生了一個ICMP不可達的差錯)，則返回so->so_error
*/
if(so->so_error){
snderr(so->so_error);
}

/**
* 如果協議請求連接且連接還沒有建立或連接請求還沒有啟動，則返回EMOTCONN.
* sosend允許只有控制信息但沒有數據的寫操作
*/
if((so->so_state & SS_ISCONNECTED) == 0){
if(so->so_proto->pr_flags & PR_CONNREQUIRED){
if((so->so_state & SS_ISCONFIRMING) == 0 && !(resid == 0 && clen != 0)){
snderr(ENOTCONN);
}
}else if(addr == 0){
snderr(EDESTADDRREQ);
}
}

/**
* 獲取發送緩存中剩餘的空閑空間位元組數
* 這是一個基於緩存高水位標記的管理上的限制，但也是sb_mbmax對它的限制，其目的是[防止太多的小豹紋消耗太多的mbuf緩存]。sosend通過放寬緩存限制到1024個位元組來給予帶外數據更高的優先順序
*/
space = sbspace(&so->so_snd);

if(flags & MSG_OOB){
space += 1024;
}

/**
* 如果atomic被置位，並且報文大於高水位標記(high-water mark),則返回EMSGSIZE;
* 報文因為太大而不被協議接受，即使緩存是空的。如果控制信息的長度大於高水位標記，同樣返回EMSGSIZE
*/
if(atomic && resid > so->so_snd.sb_hiwat || clen > so->so_snd.sb_hiwat){
snderr(EMSGSIZE);
};

/**
* 如果發送緩存中的空間不夠，數據來源於進程(而不是來源於內核中的top),並且下列條件之一成立，則sosend必須等待更多的空間
* 報文必須一次傳送給協議(atomic為真);或
* 報文可以分段傳送(即atomic為假)，但閑置空間大小低於低水位標記;或
* 報文可以分段傳送(即atomic為假)，閑置空間大小大於低水位標記，但閑置空間存放不下控制信息
* 當數據通過top傳送給sosend(即uio為NULL)時，數據已經在mbuf緩存中。因此sosend忽略緩存高、低水位標記限制，因為不需要附加的緩存來保存數據。
*/
if(space < resid + clen && uio && (atomic || space < so->so_snd.sb_lowat || space < clen)){ /** * 如果sosend必須等待緩存且socket是非阻塞的，則返回EWOULDBLOCK */ if(so->so_state & SS_NBIO){
snderr(EWOULDBLOCK);
}

sbunlock(&so->so_snd);

/**
* sosend調用sbwait等待，直到發送緩存的狀態發生變化.
* 當sbwait返回後，sosend重新進行協議處理，並且跳轉到restart獲取緩存鎖，檢查差錯和緩存空間。如果條件滿足，則繼續執行。
* 默認情況下，sbwait阻塞直到可以發送數據。通過`SO_SNDTIMEO` Socket選項改變緩存中的sb_timeo,進程可以設置等待時間的上限
*/

error = sbwait(&so->so_snd);

splx(s);
if(error){
goto out;
}

goto restart;
}
splx(s);
mp = ⊤
space -= clen;//在sosend從進程複製任何數據之前，可用緩存的數量需減去控制信息的大小

do{

/**
*一旦有了足夠的空間並且sosend也獲得了發送緩存上的鎖，則準備傳送給協議層的數據。
*/

if(NULL == uio){
/**
*如果uio為空，則說明mbuf鏈中並沒有數據或者調用出錯
*/
resid = 0;
if(flags & MSG_EOR){
top->m_flags |= M_EOR;
}
}else{
do{
/**
*如果uio不為空，則sosend必須從進程間複製數據。當PR_ATOMIC被設置時(例如，UDP),循環繼續，直到所有數據都被複制到一個mbuf鏈中。
*當sosend從進程得到所有數據後，通過循環中的break跳出循環。跳出循環後，sosend將整個數據鏈一次傳送給相應協議
*/

if(0 == top){
MGETHDR(m,M_WAIT,MT_DATA);
mlen = MHLEN;
m->m_pkthdr.len = 0;
m->m_pkthdr.rcvif = (struct ifnet*)0;
}else{
MGET(m,M_WAIT,MT_DATA);
mlen = MLEN;
}

if(resid >= MINCLSIZE && space >= MCLBYTES){
MCLGET(m,M_WAIT);

if((m->m_flags & M_EXT) == 0){
goto nopages;
}

mlen = MCLBYTES;

if(atomic && top == 0){
len = min(MCLBYTES - max_hdr,resid);
m->m_data += max_hdr;
}else{
len = min(MCLBYTES,resid);
}

space -= MCLBYTES;
}else{
nopages:
len = min(min(mlen,resid),space);
space -= len;

/**
* For datagram protocols,level room for protocol headers in first mbuf
*/

if(atomic && top == 0 && len < mlen){ MH_ALIGN(m,len); } } /** * [使用uiomove從進程複製len個位元組的數據到mbuf中]。傳送完後更新mbuf的長度 */ error = uiomove(mtod(m,caddr_t),(int)len,uio); resid = uio->uio_resid;
m->m_len = len;
*mp = m;

top->m_pkthdr.len += len;

if(error){
goto release;
}

mp = &m->next;
if(resid <= 0){ if(flags & MSG_EOR){ top->m_flags != M_EOR;
}
break;
}
}while(space > 0 && automic);

/**
* pass mbuf chain to protocol
*/

if(dontroute){
so->so_options != SO_DONTROUTE;
}

s= splnet;

/**
* 向協議層發送PRU_SEND請求或PRU_SENDOOB,協議層收到請求後會發送數據
*/
error = (*so->so_proto->pr_usrreq)(so,(flags & MSG_OOB) ? PRU_SENDOOB : PRU_SEND,top,addr,control);
splx(s);

if(dontroute){
so->so_options &= ~SO_DONTROUTE;
}

clen = 0;
control = 0;
top = 0;
mp = ⊤
if(error){
goto release;
}
}
}while(resid && space > 0);

}while(resid);

release:

/**
* 當所有數據都傳送給協議後，給Socket緩存解鎖，釋放多餘的mbuf緩存
*/
sbunlock(&so->so_snd);
out:
if(top){
m_freem(top);
}

if(control){
m_freem(control);
}

recvmsg(struct proc * p,struct recvmsg_args * uap,int * retval)
{
struct msghdr msg;

struct iovec aiov[UIO_SMALLIOV], *uiov, *iov;

int error;

/**
* 同sendmsg一樣，recvmsg將msghdr結構複製到內核。
* 如果自動分配的數組aiov太小，則分配一個更大的iovec數組，並且將數組單元從進程複製到由iov只想的內核數組。
* 並將第三個參數複製到msghdr結構中
*/

if(error = copyin((caddr_t)uap->msg,(caddr_t)&msg,sizeof(msg))){
return (error);
}

if((u_int)msg.msg_iovlen >= UIO_SMALLIOV){
if((u_int)msg.msg_iovlen >= UIO_MAXIOV){
return (EMSGSIZE);
}
MALLOC(iov,struct iovec * ,sizeof(struct iovec) * (u_int)msg.msg_iovlen,M_IOV,M_WAITOK);
}else{
iov = aiov;
}

msg.msg_flags = uap->flags;
uiov = msg.msg_iov;
msg.msg_iov = iov;

if(error = copyin((caddr_t)uiov,(caddr_t)iov,(unsigned)(msg.msg_iovlen * sizeof(struct iovec)))){
goto done;
}

/**
* recvit收完數據後，將更新過的緩存長度和標誌的msghdr結構再複製到進程。
*/

if((error = recvit(p,uap->s,&msg,(caddr_t)0,retval)) == 0){
msg.msg_iov = uiov;
error = copyout((caddr_t)&msg,(caddr_t)uap->msg,sizeof(msg));
}

if(error = getsock(p->p_fd,s,&fp)){
return (error);
}

auio.uio_iov = mp->msg_iov;
auio.uio_iovcnt = mp->msg_iovlen;
auio.uio_segflg = UIO_USERSPACE;
auio.uio_rw = UIO_READ;
auio.uio_procp = p;
auio.uio_offset = 0;
auio.uio_resid = 0;
iov = mp->msg_iov;

for(i = 0;i < mp->msg_iovlen;i++;iov++){
if(iov->iov_len < 0){ return (EINVAL); } if((auio.uio_resid += iov->iov_len) < 0){ return (EINVAL); } } len = auio.uio_resid; /** * soreceive實現從socket緩存中接收數據的最複雜的功能。 * 傳送的位元組數保存在*retisze中，並返回給進程。 * 如果有些數據已經複製到進程後信號出現或阻塞出現(len不等於uio_resid),則忽略差錯，並返回已經傳送的位元組 */ if(error = soreceive((struct socket*)fp->f_data,&from,&auio,(struct mbuf**)0,mp->msg_control ? &control : (struct mbuf**)0,&mp->msg_flags)){
if(auio.uio_resid != len && (error == ERESTART || error == EINTR || error == EWOULDBLOCK)){
error = 0;
}
}

if(error){
goto out;
}

*retsize = len - auio.uio_resid;

/**
* 如果進程傳入了一個存放地址或控制信息或者兩者都有的緩存，則recvit將結果寫入該緩存，並且根據soreceive返回的結果調整它們的長度。
* 如果緩存太小，則地址信息可能被截掉。如果進程在發送讀請求之前保存緩存的長度，將該長度同內核返回的namelenp變數(或sockaddr結構的長度域)相比較就可能發現這個錯誤。通過設置msg_flags中的MSG_CTRUNC標誌來報告這種差錯。
*/

if(mp->msg_name){
len = mp->msg_namelen;

if(len <= 0 || from == 0){ len = 0; }else{ if(len > from->m_len){
len = from->m_len;
}

if(error = copyout(mtod(from,caddr_t),(caddr_t)mp->msg_name,(unsigned)len)){
goto out;
}

mp->msg_namelen = len;
if(namelenp && (error = copyout((caddr_t)&len,namelenp,sizeof(int)))){
goto out;
}
}

if(mp->msg_control){
len = mp->msg_controllen;

if(len <= 0 || control == 0){ len = 0; }else{ if(len >= control->m_len){
len = control->m_len;
}else{
mp->msg_flags |= MSG_CTRUNC;
}

error = copyout((caddr_t)mtod(control,caddr_t),(caddr_t)mp->msg_control,(unsigned)len);
}

mp->msg_controllen = len;

}

out:
/**
* 從out開始，釋放存儲源地址和控制信息的mbuf緩存
*/
if(from){
m_freem(from);
}

if(control){
m_freem(control);
}

soreceive(struct socket * so,struct mbuf ** paddr,struct uio * uio,struct mbuf **mp0,struct mbuf **controlp,int * flagsp)
{
struct mbuf *m,**mp;
int flags,len,error,s,offset;
//將pr指向socket協議的交換結構
struct protosw * pr = so->so_proto;
struct mbuf * nextrecord;
int moff,type;

/**
* 將uio_resid(接收請求的大小)保存在orig_resid
* 如果將控制或地址信息從內核複製到進程，則將orig_resid清0.soreceive函數的最後處理要利用這一事實。
*/
int orig_resid = uio->uio_resid;

mp = mp0;

if(paddr){
*paddr = 0;
}

if(controlp){
*controlp = 0;
}

if(flags){
flags = *flagsp & ~MSG_EOR;
}else{
flags = 0;
}

/**
* MSG_OOB processing and implicit connection confirmation
* 處理帶外數據
*/

if(flags & MSG_OOB){
/**
* 因為OOB數據不存放在接收緩存中，所以soreceive為其分配一塊標準的mbuf
*/
m = m_get(M_WAIT,MT_DATA);

/**
*給協議發送PRU_RCVOOB請求，並通過循環將協議返回的數據複製到uio指定的緩存中。複製完成後，soreceive返回0或差錯代碼
*/

error = (*pr->pr_usrreq)(so,PRU_RCVOOB,m,(struct mbuf*)(flags & MSG_PEEK),(struct mbuf*)0);//給協議發送PRU_RCVOOB請求，將帶外數據複製到m中

if(error){
goto bad;
}

do{

//將m中的數據(即協議返回的帶外數據)複製到uio指定的緩存中
error = uiomove(mtod(m,caddr_t),(int)min(uio->uio_resid,m->m_len),uio);

}while(uio->uio_resid && error == 0 && m);

bad:
if(m){
m_freem(m);
}

return (error);
}

/**
* 如果mp不為空，則表明將數據存放在其指向的mbuf鏈中。這裡我們首先將mbuf鏈中的第一個mbuf清空
*/
if(mp){
*mp = (struct mbuf*)0;
}

/**
* 如果socket處於SO_ISCONFIRMING狀態，PRU_RCVD請求告知協議進程想要接收數據
*/
if(so->so_state & SS_ISCONFORMING && uio->uio_resid){
(*pr->pr_usrreq)(so,PRU_RCVD,(struct mbuf*)0,(struct mbuf*)0,(struct mbuf*)0);
}

restart:

/**
* 在訪問接收緩存之前，調用sblock給緩存加鎖。如果flags中沒有設置MSG_DONTWAIT標誌，則soreceive必須等待加鎖成功
*/
if(error = sblock(&so->so_rcv,SBLOCKWAIT(flags))){
return (error);
}

/**
* 掛起協議處理，使得在檢查緩存過程中soreceive不被中斷
*/
s = splnet;

/**
* m是接收緩存中的第一個mbuf鏈上的第一個mbuf
*/
m = so->so_rcv.sb_mb;

/**
* if necessary ,wait for data to arrive
* 讀調用的請求能滿足嗎?如果不能則等待更多的數據
*/

if(m == 0 || ((flags & MSG_DONTWAIT) == 0 && so->so_rcv.sb_cc < uio->uio_resid) && (so->so_rcv.sb_cc < so->so_rcv.sb_lowat || ((flags & MSG_WAITALL) && uio->uio_resid <= so->so_rcv.sb_hiwat)) && m->m_nextpkt == 0 && (pr->pr_flags & PR_ATOMIC) == 0){
if(so->so_error){
if(m){
goto dontblock;
}

error = so->so_error;

if((flags & MSG_PEEK) == 0){
so->so_error = 0;
}

goto release;
}

if(so->so_state & SS_CANTRCVMORE){
if(m){
goto dontblock;
}else{
doto release;
}
}

for(;m;m->next){
if(m->m_type == MT_OOBDATA || (m->m_flags & M_EOR)){
m = so->so_rcv.sb_mb;
goto dontblock;
}
}

if((so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING)) == 0 && (so->so_proto->pr_flags & PR_CONNREQUIRED)){
error = ENOTCONN;
goto release;
}

if(uio->uio_resid == 0){
goto release;
}

if((so->so_state & SS_NBIO) || (flags & MSG_DONTWAIT)){
error = EWOULDBLOCK;
goto release;
}

sbunlock(&so->so_rcv);

/**
* 等待更多的數據
* 同sosend中一樣，進程能夠利用SO_RCVTIMEO Socket選項為sbwait設置一個接收定時器。如果在數據到達之前定時器超時，則sbwait返回EWOULDBLOCK
*/
error = sbwait(&so->so_rcv);

splx(s);

if(error){
return (error);
}

goto restart;

}
dontblock:
if(uio->uio_procp){
uio->uio_procp->p_stats->p_ru.ru_msgrcv++;
}

/**
* nextrecord 指向接收緩存的下一條記錄。
* 在soreceive的後面，當第一個鏈被丟棄後，該指針被用來將剩餘的mbuf放入socket緩存
*/
nextrecord = m->m_nextpkt;

/**
* 處理地址和控制信息
*/

/**
* 如果協議提供地址信息，例如UDP,則將從mbuf鏈中刪除含地址的mbuf,並通過*paddr返回。如果，paddr為空，則地址信息被丟棄
*/
if(pr->pr_flags & PR_ADDR){
orig_resid = 0;

if(flags & MSG_PEEK){//接收數據的副本而不取走
if(paddr){
*paddr = m_copy(m,0,m->m_len);
}

m = m->m->m_next;
}else{
sbfree(&so->so_rcv,m);

if(paddr){
*paddr = m;
so->so_rcv.sb_mb = m->m_next;
m->m_next = 0;
m = so->so_rcv.sb_mb;
}else{
MFREE(m,so->so_rcv.sb_mb);
m = so->so_rcv.sb_mb;
}
}
}

while(m && m->m_type == MT_CONTROL && error == 0){

if(flags & MSG_PEEK){
if(controlp){
*controlp = m_copy(m,0,m->m_len);
}

m = m->m_next;
}else{
sbfree(&so->so_rcv,m);
if(controlp){
if(pr->pr_domain->dom_externalize && mtod(m,struct cmsghdr *)->cmsg_type == SCM_RIGHTS){
error = (*pr->pr_domain->dom_externalize)(m);
}

*controlp = m;
so->so_rcv.sb_mb = m->m_next;
m->m_next = 0;
m = m->so_rcv.sb_mb;
}
}

if(controlp){
orig_resid = 0;
controlp = &(*controlp)->m_next;
}

}

/**
* 處理完所有的控制mbuf後,m指向鏈中的下一個mbuf.
* 如果在地址或控制信息的後面，鏈中沒有其它的mbuf,則m為空
*
*/

if(m){
if((flags & MSG_PEEK) == 0){
m->m_nextpkt = nextrecord;
}

type = m->m_type;

if(MT_OOBDATA == type){
flags |= MSG_OOB;
}
}

/**
* 傳送數據
* 當MSG_PEEK被置位時，將為傳送的下一個位元組的偏移位置
* 當MSG_PEEK被置位時，OOB標記的偏移位置
* uio_resid表示還未傳送的位元組數
* len表示從本mbuf中將要傳送的位元組數;如果uio_resid比較小或靠OOB標記比較近，則len可能小於m_len
*/

moff = 0;
offset = 0;

while(m && uio->uio_resid > 0 && error == 0){
if(m->m_type == MT_OOBDATA){
if(type != MT_OOBDATA){
break;
}
}else if(type == MT_OOBDATA){
break;
}

so->so_state &= ~SS_RCVATMARK;

len = uio->uio_resid;

if(so->so_oobmark && len > so->so_oobmark - offset){
len = so->so_oobmark - offset;
}

if(len > m->m_len - moff){
len = m->m_len - moff;
}

/**
* 如果將數據傳送到uio緩存，則調用uiomove。如果數據是作為一個mbuf鏈返回的，則更新uio_resid的值，使其等於傳送的位元組數
*/
if(mp == 0){
splx(s);
//將數據從接收緩存傳送到uio緩存中
error = uiomove(mtod(m,caddr_t)+moff,(int)len,uio);
s = splnet;
}else{
uio->uio_resid -= len;
}

/**
* 調整指針和偏移準備傳送下一個mbuf
*/

if(len == m->m_len - moff){
if(m->m_flags & M_EOR){
flags != MSG_EOR;
}

if(flags & MSG_PEEK){
m = m->m_next;
moff = 0;
}else{
nextrecord = m->m_nextpkt;
sbfree(&so->so_rcv,m);

if(mp){
*mp = m;
mp = &m->m_next;
so->so_rcv.sb_mb = m = m->m_next;
*mp = (struct mbuf*)0;
}else{
MFREE(m,so->so_rcv.sb_mb);
m = so->so_rcv.sb_mb;
}

if(m){
m->m_nextpkt = nextrecord;
}
}else{
if(mp){
//將數據從接收緩存拷貝到mp指向的mbuf鏈
*mp = m_copy(m,0.len,M_WAIT);
}

m->m_data += len;
m_m_len -= len;
so->so_rcv.sb_cc -= len;
}
}

if(so->so_oobmark){
if((flags & MSG_PEEK) == 0){
so->so_oobmark -= len;
if(so->so_oobmark == 0){
so->so_state |= SS_RCVATMARK;
break;
}
}else{
offset += len;
if(offset == so->so_oobmark){
break;
}
}
}

if(flags & MSG_EOR){
BREAK;
}

/**
* 當設置了MSH_WAITALL標誌，並且讀請求還沒有完成，則循環將等待更多的數據到達
* If the MSG_WAITALL flag is set (for non-atomic socket)
* we must not quit util "uio->uio_resid == 0"or an error termination.
* If a signal/timeout occurs ,return with a short count but without error
* Keep sockbuf locked against other readers
*/

while(flags & MSG_WAITALL && m == 0 && uio->uio_resid > - && !sosendallatonce(so) && !nextrecord){
if(so->so_error || so->so_state & SS_CANTRCVMORE){
break;
}

//等待
error = sbwait(&so->so_rcv);

if(error){
sbunlock(&so->so_rcv);
splx(s);
return (0);
}

if(m = so->so_rcv.sb_mb){
nextrecord = m->m_nextpkt;
}
}
}

/**
*cleanup
*/

if(m && pr->pr_flags & PR_ATOMIC){
flags != MSG_TRUNC;
if((flags & MSG_PEEK) == 0){
(void)sbdroprecord(&so->so_rcv);
}
}

if((flags & MSG_PEEK) == 0){
if(m == 0){
so->so_rcv.sb_mb = nextrecord;
}

if(pr->pr_flags & PR_WANTRCVD && so->so_pcb){
(*pr->pr_usrreq)(so,PRU_RCVD,(struct mbuf*)0,(struct mbuf*)flags ,(struct mbuf*)0,(struct mbuf *)0);
}
}

if(orig_resid == uio->uio_resid && orig_resid && (flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0){
sbunlock(&so->so_rcv);
splx(s);
goto restart;
}

if(flagsp){
*flagsp |- flags;
}

release:
sbunlock(&so->so_rcv);
splx(s);

select(struct proc * p,struct select_args * uap,int * retval)
{
/**
* 在棧中分配兩個數組:ibits和obits,每個數組有三個單元，每個單元為一個描述符集合。
*/
fd_set = ibits[3],obits[3];

struct timeval atv;

int s,ncoll,error = 0,timo;

/**
* ni等於用來存放nd個比特(1個描述符佔1個比特)的比特掩碼所需的位元組數
*/
u_int ni;

bzero((caddr_t)ibits,sizeof(ibits));
bzero((caddr_t)obits,sizeof(obits));

/**
* select系統調用的第一個參數nd，必須不大於進程的描述符的最大數量
*/
if(uap->nd > FD_SETSIZE){
return (EINVAL);
}

/**
* 如果nd大於當前分配給進程的描述符個數，則將其減少到當前分配給進程的描述的個數
*/
if(uap->nd > p->p_fd->fd_nfiles){
uap->nd = p->p_fd->fd_nfiles;
}

/**
* ni等於用來存放nd個比特(1個描述符佔1個比特)的比特掩碼所需的位元組數
*/
ni = howmany(uap->nd,NFDBITS) * sizeof(fd_mask);

/**
* getbits宏copyin從進程那裡將文件描述符集合傳遞到ibits中的三個文件描述符集合.
* 如果文件描述符集合指針為空，則不需要複製
*/
#define getbits(name,x)
if(uap->name &&
(error = copyin((caddr_t)uap->name,(caddr_t)&ibits[x],ni)))
goto done;
}
getbits(in,0);
getbits(ou,1);
getbits(ex,2);
#undef getbits

/**
* 設置超時值
* 如果tv為空，則將timeo設置成0，select將無限期等待
*/
if(uap->tv){

/**
* 如果tv非空，則將超時值複製到內核
*/
error = copyin((caddr)t)uap->tv,(caddr_t)&atv,sizeof(atv));

if(error)[
goto done;
}

/**
* 調用itimerfix將超時值按硬體時鐘的解析度取整
*/
if(itimerfix(&atv)){
error = EINVAL;
goto done;
}

s = splclock;

/**
* 調用timevaladd將當前時間加到超時值中
*/
timevaladd(&atv,(struct timeval*)&time);
/**
* 調用hzto計算[從啟動到超時之間]的時鐘滴答數，並保存在timo中
*/
timo = hzto(&atv);

/**
* 如果計算出來的時鐘滴答數為0，則將timo設置為1，從而防止select無限期等待,[實現利用全0的timeval結構來實現非阻塞操作]
* Avoid inadvertently sleeping forever
*/

if(0 == timo){
timo = 1;
}

splx(s);

}else{
timo = 0;//如果tv為空，則將timeo設置成0，select將無限期等待
}

retry:

/**
* 掃描進程指示的文件描述符，當一個或多個文件描述符處於就緒狀態或者定時器超時或信號出現時返回
*/

ncoll = nselcoll;
p->p_flag |= P_SELECT;
error = selscan(p,ibits,obits,uap->nd,retval);

if(error || *retval){
goto done;
}

s = splhigh;

/* this should be timercmp(&time,&atv,>=) */

if(uap->tv && (time.tv_sec > atv.tv_sec || time.tv_sec == atv.tv_sec && time.tv_tv_usec >= atv.tv_usec)){
splx(s);
goto done;
}

if((p->p_flag & P_SELECT) == 0 || nselcoll != ncoll){
splx(s);
goto retry;
}

p->p_flag &= ~P_SELECT;

error = tsleep((caddr_t)&selwait,PSOCK|PCATCH,"select",timo);

splx(s);

if(0 == error){
goto retry;
}

done:
p->p_flag &= ~P_SELECT;
/* select is not restarted after signals ... */

if(ERESTART == error){
error = EINTR;
}

if(EWOULDBLOCK == error){
error = 0;
}

#define putbits(name,x)
if(uap->name &&
(error2 = copyout((caddr_t)&bits[x],(caddr_t)uap->name,nil))){
error = error2;
}

if(0 == error){
int error2;

putbits(in,0);
putbits(ou,1);
putbits(ex,2);
}
#undef putbits

fd_mask bits;

int n = 0;

static int flag[3] = {FREAD,FWRITE,0};

/**
* 第一個for循環依次查看三個文件描述符集合:讀、寫、例外
*/
for(int msk = 0;msk < 3;msk++){ /** * 第二個for循環在每個文件描述符集合(讀、寫、例外)內部循環，這個循環在集合中每個32bit(NFDBITS)循環依次 */ for(int i = 0;i < nfd;i+= NFDBITS){ bits = ibits[msk].fds_bits[i / NFDBITS]; while((j = ffs(bits)) && (fd = i + --j) < nfd){ bits &= ~(1 << j); struct file *fp = fdp->fd_ofiles[fd];

if(NULL == fp){
return (EBADF);
}

/**
* 當發現某個文件描述符的狀態為準備就緒時，設置輸出文件描述符集合中相對應的比特位。並將n(狀態就緒的描述符個數)加1
*/
if((*fp->f_ops->fo_select)(fp,flag[msk],p)){
FD_SET(fd,&obits[msk]);
n++;
}
}
}
}

/**
* 當出現如下情況是，可以認為socket可寫:
* - 發送緩存中的可用空間大於低水位
*/
#define sowriteable(so)
(sbspace(&so->so_snd) >= so_snd.sb_lowat && (so->so_state & SS_ISCONNECTED) || ((so->so_proto->pr_flags & PR_CONNREQURED) == 0 || so->so_state & SS_CANTSENDMORE || so->error))

soo_select(struct file * fp,int which,struct proc * p)
{
struct socket * so = (struct socket *)fp->f_data;

int s = splnet;

switch(which){
case FREAD:{
if(soreadable(so)){
splx(s);
return (1);
}

selrecord(p,&so->so_rcv.sb_sel);
so->so_rcv.sb_flags |= SB_SEL;
break;
}

case FWRITE:{
if(sowriteable(so)){
splx(s);
return (1);
}

selrecord(p,&so->so_snd.sb_sel);
so->so_snd.sb)flag |= SB_SEL;
break;
}

case 0:{
if(so->so_oobmark || (so->so_state & SS_RCVATMARK)){
splx(s);
return (1);
}

selrecord(p,&so->so_rcv.sb_sel);
so->so_rcv.sb_flags |= SB_SEL;
break;
}
}

splx(s);