之前对于TCP接收过程中的三个队列的关系之前没搞清楚。
这几天，在同事邱的帮助下，终于把关系理清了，故特此做个笔记。
一、在软中断中加入数据包
1615 int tcp_v4_rcv(struct sk_buff *skb)
1616 {
1617 const struct iphdr *iph;
1618 struct tcphdr *th;
1619 struct sock *sk;
1620 int ret;
1621 struct net *net = dev_net(skb->dev);
1622
1623 if (skb->pkt_type != PACKET_HOST)
1624 goto discard_it;
1625
1626 /* Count it even if it‘s bad */
1627 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
1628
1629 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1630 goto discard_it;
1631
1632 th = tcp_hdr(skb);
1633
1634 if (th->doff < sizeof(struct tcphdr) / 4)
1635 goto bad_packet;
1636 if (!pskb_may_pull(skb, th->doff * 4))
1637 goto discard_it;
1638
1639 /* An explanation is required here, I think.
1640 * Packet length and doff are validated by header prediction,
1641 * provided case of th->doff==0 is eliminated.
1642 * So, we defer the checks. */
1643 if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb))
1644 goto bad_packet;
1645
1646 th = tcp_hdr(skb);
1647 iph = ip_hdr(skb);
1648 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1649 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1650 skb->len - th->doff * 4);
1651 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1652 TCP_SKB_CB(skb)->when = 0;
1653 TCP_SKB_CB(skb)->flags = iph->tos;
1654 TCP_SKB_CB(skb)->sacked = 0;
1655
1656 sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
1657 if (!sk)
1658 goto no_tcp_socket;
1659
1660 process:
1661 if (sk->sk_state == TCP_TIME_WAIT)
1662 goto do_time_wait;
1663
1664 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
1665 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1666 goto discard_and_relse;
1667 }
1668
1669 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1670 goto discard_and_relse;
1671 nf_reset(skb);
1672
1673 if (sk_filter(sk, skb))
1674 goto discard_and_relse;
1675
1676 skb->dev = NULL;
1677
1678 bh_lock_sock_nested(sk);
1679 ret = 0;
1680 if (!sock_owned_by_user(sk)) {
1681 #ifdef CONFIG_NET_DMA
1682 struct tcp_sock *tp = tcp_sk(sk);
1683 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1684 tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
1685 if (tp->ucopy.dma_chan)
1686 ret = tcp_v4_do_rcv(sk, skb);
1687 else
1688 #endif
1689 {
1690 if (!tcp_prequeue(sk, skb)) //先尝试加入prequeue
1691 ret = tcp_v4_do_rcv(sk, skb); //否则加入sk_receive_queue
1692 }
1693 } else if (unlikely(sk_add_backlog(sk, skb))) { //加入backlog
1694 bh_unlock_sock(sk);
1695 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
1696 goto discard_and_relse;
1697 }
1698 bh_unlock_sock(sk);
1699
1700 sock_put(sk);
1701
1702 return ret;
1703
1704 no_tcp_socket:
1705 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1706 goto discard_it;
1707
1708 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1709 bad_packet:
1710 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
1711 } else {
1712 tcp_v4_send_reset(NULL, skb);
1713 }
1714
1715 discard_it:
1716 /* Discard frame. */
1717 kfree_skb(skb);
1718 return 0;
1719
1720 discard_and_relse:
1721 sock_put(sk);
1722 goto discard_it;
1723
1724 do_time_wait:
1725 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1726 inet_twsk_put(inet_twsk(sk));
1727 goto discard_it;
1728 }
1729
1730 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1731 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
1732 inet_twsk_put(inet_twsk(sk));
1733 goto discard_it;
1734 }
1735 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
1736 case TCP_TW_SYN: {
1737 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
1738 &tcp_hashinfo,
1739 iph->daddr, th->dest,
1740 inet_iif(skb));
1741 if (sk2) {
1742 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
1743 inet_twsk_put(inet_twsk(sk));
1744 sk = sk2;
1745 goto process;
1746 }
1747 /* Fall through to ACK */
1748 }
1749 case TCP_TW_ACK:
1750 tcp_v4_timewait_ack(sk, skb);
1751 break;
1752 case TCP_TW_RST:
1753 goto no_tcp_socket;
1754 case TCP_TW_SUCCESS:;
1755 }
1756 goto discard_it;
1757 }
1385 * This routine copies from a sock struct into the user buffer.
1386 *
1387 * Technical note: in 2.3 we work on _locked_ socket, so that
1388 * tricks with *seq access order and skb->users are not required.
1389 * Probably, code can be easily improved even more.
1390 */
1391
1392 int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
1393 size_t len, int nonblock, int flags, int *addr_len)
1394 {
1395 struct tcp_sock *tp = tcp_sk(sk);
1396 int copied = 0;
1397 u32 peek_seq;
1398 u32 *seq;
1399 unsigned long used;
1400 int err;
1401 int target; /* Read at least this many bytes */
1402 long timeo;
1403 struct task_struct *user_recv = NULL;
1404 int copied_early = 0;
1405 struct sk_buff *skb;
1406 u32 urg_hole = 0;
1407
1408 lock_sock(sk);
1409
1410 TCP_CHECK_TIMER(sk);
1411
1412 err = -ENOTCONN;
1413 if (sk->sk_state == TCP_LISTEN)
1414 goto out;
1415
1416 timeo = sock_rcvtimeo(sk, nonblock);
1417
1418 /* Urgent data needs to be handled specially. */
1419 if (flags & MSG_OOB)
1420 goto recv_urg;
1421
1422 seq = &tp->copied_seq;
1423 if (flags & MSG_PEEK) {
1424 peek_seq = tp->copied_seq;
1425 seq = &peek_seq;
1426 }
1427
1428 target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
1429
1430 #ifdef CONFIG_NET_DMA
1431 tp->ucopy.dma_chan = NULL;
1432 preempt_disable();
1433 skb = skb_peek_tail(&sk->sk_receive_queue);
1434 {
1435 int available = 0;
1436
1437 if (skb)
1438 available = TCP_SKB_CB(skb)->seq + skb->len - (*seq);
1439 if ((available < target) &&
1440 (len > sysctl_tcp_dma_copybreak) && !(flags & MSG_PEEK) &&
1441 !sysctl_tcp_low_latency &&
1442 dma_find_channel(DMA_MEMCPY)) {
1443 preempt_enable_no_resched();
1444 tp->ucopy.pinned_list =
1445 dma_pin_iovec_pages(msg->msg_iov, len);
1446 } else {
1447 preempt_enable_no_resched();
1448 }
1449 }
1450 #endif
1451
1452 do {
1453 u32 offset;
1454
1455 /* Are we at urgent data? Stop if we have read anything or have SIGURG pending. */
1456 if (tp->urg_data && tp->urg_seq == *seq) {
1457 if (copied)
1458 break;
1459 if (signal_pending(current)) {
1460 copied = timeo ? sock_intr_errno(timeo) : -EAGAIN;
1461 break;
1462 }
1463 }
1464
1465 /* Next get a buffer. */
1466
1467 skb_queue_walk(&sk->sk_receive_queue, skb) { //从sk_receive_queue中依次获得待读取的段
1468 /* Now that we have two receive queues this
1469 * shouldn‘t happen.
1470 */
1471 if (WARN(before(*seq, TCP_SKB_CB(skb)->seq),
1472 KERN_INFO "recvmsg bug: copied %X "
1473 "seq %X rcvnxt %X fl %X\n", *seq,
1474 TCP_SKB_CB(skb)->seq, tp->rcv_nxt,
1475 flags))
1476 break;
1477
1478 offset = *seq - TCP_SKB_CB(skb)->seq;
1479 if (tcp_hdr(skb)->syn)
1480 offset--;
1481 if (offset < skb->len)
1482 goto found_ok_skb;
1483 if (tcp_hdr(skb)->fin)
1484 goto found_fin_ok;
1485 WARN(!(flags & MSG_PEEK), KERN_INFO "recvmsg bug 2: "
1486 "copied %X seq %X rcvnxt %X fl %X\n",
1487 *seq, TCP_SKB_CB(skb)->seq,
1488 tp->rcv_nxt, flags);
1489 }
1490
1491 /* Well, if we have backlog, try to process it now yet. */
1492
1493 if (copied >= target && !sk->sk_backlog.tail)
1494 break; //跳出循环，处理backlog
1495
1496 if (copied) {
1497 if (sk->sk_err ||
1498 sk->sk_state == TCP_CLOSE ||
1499 (sk->sk_shutdown & RCV_SHUTDOWN) ||
1500 !timeo ||
1501 signal_pending(current))
1502 break;
1503 } else {
1504 if (sock_flag(sk, SOCK_DONE))
1505 break;
1506
1507 if (sk->sk_err) {
1508 copied = sock_error(sk);
1509 break;
1510 }
1511
1512 if (sk->sk_shutdown & RCV_SHUTDOWN)
1513 break;
1514
1515 if (sk->sk_state == TCP_CLOSE) {
1516 if (!sock_flag(sk, SOCK_DONE)) {
1517 /* This occurs when user tries to read
1518 * from never connected socket.
1519 */
1520 copied = -ENOTCONN;
1521 break;
1522 }
1523 break;
1524 }
1525
1526 if (!timeo) {
1527 copied = -EAGAIN;
1528 break;
1529 }
1530
1531 if (signal_pending(current)) {
1532 copied = sock_intr_errno(timeo);
1533 break;
1534 }
1535 }
1536
1537 tcp_cleanup_rbuf(sk, copied);
1538
1539 if (!sysctl_tcp_low_latency && tp->ucopy.task == user_recv) {
1540 /* Install new reader */
1541 if (!user_recv && !(flags & (MSG_TRUNC | MSG_PEEK))) {
1542 user_recv = current;
1543 tp->ucopy.task = user_recv;
1544 tp->ucopy.iov = msg->msg_iov;
1545 }
1546
1547 tp->ucopy.len = len;
1548
1549 WARN_ON(tp->copied_seq != tp->rcv_nxt &&
1550 !(flags & (MSG_PEEK | MSG_TRUNC)));
1551
1552 /* Ugly... If prequeue is not empty, we have to
1553 * process it before releasing socket, otherwise
1554 * order will be broken at second iteration.
1555 * More elegant solution is required!!!
1556 *
1557 * Look: we have the following (pseudo)queues:
1558 *
1559 * 1. packets in flight
1560 * 2. backlog
1561 * 3. prequeue
1562 * 4. receive_queue
1563 *
1564 * Each queue can be processed only if the next ones
1565 * are empty. At this point we have empty receive_queue.
1566 * But prequeue _can_ be not empty after 2nd iteration,
1567 * when we jumped to start of loop because backlog
1568 * processing added something to receive_queue.
1569 * We cannot release_sock(), because backlog contains
1570 * packets arrived _after_ prequeued ones.
1571 *
1572 * Shortly, algorithm is clear --- to process all
1573 * the queues in order. We could make it more directly,
1574 * requeueing packets from backlog to prequeue, if
1575 * is not empty. It is more elegant, but eats cycles,
1576 * unfortunately.
1577 */
1578 if (!skb_queue_empty(&tp->ucopy.prequeue))
1579 goto do_prequeue; //处理prequeue
1580
1581 /* __ Set realtime policy in scheduler __ */
1582 }
1583
1584 #ifdef CONFIG_NET_DMA
1585 if (tp->ucopy.dma_chan)
1586 dma_async_memcpy_issue_pending(tp->ucopy.dma_chan);
1587 #endif
1588 if (copied >= target) {
1589 /* Do not sleep, just process backlog. */
1590 release_sock(sk);
1591 lock_sock(sk);
1592 } else
1593 sk_wait_data(sk, &timeo);
1594
1595 #ifdef CONFIG_NET_DMA
1596 tcp_service_net_dma(sk, false); /* Don‘t block */
1597 tp->ucopy.wakeup = 0;
1598 #endif
1599
1600 if (user_recv) {
1601 int chunk;
1602
1603 /* __ Restore normal policy in scheduler __ */
1604
1605 if ((chunk = len - tp->ucopy.len) != 0) {
1606 NET_ADD_STATS_USER(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMBACKLOG, chunk);
1607 len -= chunk;
1608 copied += chunk;
1609 }
1610
1611 if (tp->rcv_nxt == tp->copied_seq &&
1612 !skb_queue_empty(&tp->ucopy.prequeue)) {
1613 do_prequeue:
1614 tcp_prequeue_process(sk); //pruqueue的处理函数
1615
1616 if ((chunk = len - tp->ucopy.len) != 0) {
1617 NET_ADD_STATS_USER(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMPREQUEUE, chunk);
1618 len -= chunk;
1619 copied += chunk;
1620 }
1621 }
1622 }
1623 if ((flags & MSG_PEEK) &&
1624 (peek_seq - copied - urg_hole != tp->copied_seq)) {
1625 if (net_ratelimit())
1626 printk(KERN_DEBUG "TCP(%s:%d): Application bug, race in MSG_PEEK.\n",
1627 current->comm, task_pid_nr(current));
1628 peek_seq = tp->copied_seq;
1629 }
1630 continue;
1631
1632 found_ok_skb:
1633 /* Ok so how much can we use? */
1634 used = skb->len - offset;
1635 if (len < used)
1636 used = len;
1637
1638 /* Do we have urgent data here? */
1639 if (tp->urg_data) {
1640 u32 urg_offset = tp->urg_seq - *seq;
1641 if (urg_offset < used) {
1642 if (!urg_offset) {
1643 if (!sock_flag(sk, SOCK_URGINLINE)) {
1644 ++*seq;
1645 urg_hole++;
1646 offset++;
1647 used--;
1648 if (!used)
1649 goto skip_copy;
1650 }
1651 } else
1652 used = urg_offset;
1653 }
1654 }
1655
1656 if (!(flags & MSG_TRUNC)) {
1657 #ifdef CONFIG_NET_DMA
1658 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1659 tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
1660
1661 if (tp->ucopy.dma_chan) {
1662 tp->ucopy.dma_cookie = dma_skb_copy_datagram_iovec(
1663 tp->ucopy.dma_chan, skb, offset,
1664 msg->msg_iov, used,
1665 tp->ucopy.pinned_list);
1666
1667 if (tp->ucopy.dma_cookie < 0) {
1668
1669 printk(KERN_ALERT "dma_cookie < 0\n");
1670
1671 /* Exception. Bailout! */
1672 if (!copied)
1673 copied = -EFAULT;
1674 break;
1675 }
1676
1677 dma_async_memcpy_issue_pending(tp->ucopy.dma_chan);
1678
1679 if ((offset + used) == skb->len)
1680 copied_early = 1;
1681
1682 } else
1683 #endif
1684 {
1685 err = skb_copy_datagram_iovec(skb, offset,
1686 msg->msg_iov, used);
1687 if (err) {
1688 /* Exception. Bailout! */
1689 if (!copied)
1690 copied = -EFAULT;
1691 break;
1692 }
1693 }
1694 }
1695
1696 *seq += used;
1697 copied += used;
1698 len -= used;
1699
1700 tcp_rcv_space_adjust(sk);
1701
1702 skip_copy:
1703 if (tp->urg_data && after(tp->copied_seq, tp->urg_seq)) {
1704 tp->urg_data = 0;
1705 tcp_fast_path_check(sk);
1706 }
1707 if (used + offset < skb->len)
1708 continue;
1709
1710 if (tcp_hdr(skb)->fin)
1711 goto found_fin_ok;
1712 if (!(flags & MSG_PEEK)) {
1713 sk_eat_skb(sk, skb, copied_early);
1714 copied_early = 0;
1715 }
1716 continue;
1717
1718 found_fin_ok:
1719 /* Process the FIN. */
1720 ++*seq;
1721 if (!(flags & MSG_PEEK)) {
1722 sk_eat_skb(sk, skb, copied_early);
1723 copied_early = 0;
1724 }
1725 break;
1726 } while (len > 0);
1727
1728 if (user_recv) {
1729 if (!skb_queue_empty(&tp->ucopy.prequeue)) {
1730 int chunk;
1731
1732 tp->ucopy.len = copied > 0 ? len : 0;
1733
1734 tcp_prequeue_process(sk);
1735
1736 if (copied > 0 && (chunk = len - tp->ucopy.len) != 0) {
1737 NET_ADD_STATS_USER(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMPREQUEUE, chunk);
1738 len -= chunk;
1739 copied += chunk;
1740 }
1741 }
1742
1743 tp->ucopy.task = NULL;
1744 tp->ucopy.len = 0;
1745 }
1746
1747 #ifdef CONFIG_NET_DMA
1748 tcp_service_net_dma(sk, true); /* Wait for queue to drain */
1749 tp->ucopy.dma_chan = NULL;
1750
1751 if (tp->ucopy.pinned_list) {
1752 dma_unpin_iovec_pages(tp->ucopy.pinned_list);
1753 tp->ucopy.pinned_list = NULL;
1754 }
1755 #endif
1756
1757 /* According to UNIX98, msg_name/msg_namelen are ignored
1758 * on connected socket. I was just happy when found this 8) --ANK
1759 */
1760
1761 /* Clean up data we have read: This will do ACK frames. */
1762 tcp_cleanup_rbuf(sk, copied);
1763
1764 TCP_CHECK_TIMER(sk);
1765 release_sock(sk);
1766 return copied;
1767
1768 out:
1769 TCP_CHECK_TIMER(sk);
1770 release_sock(sk); //backlog的处理函数
1771 return err;
1772
1773 recv_urg:
1774 err = tcp_recv_urg(sk, msg, len, flags);
1775 goto out;
1776 }
1240 static void tcp_prequeue_process(struct sock *sk)
1241 {
1242 struct sk_buff *skb;
1243 struct tcp_sock *tp = tcp_sk(sk);
1244
1245 NET_INC_STATS_USER(sock_net(sk), LINUX_MIB_TCPPREQUEUED);
1246
1247 /* RX process wants to run with disabled BHs, though it is not
1248 * necessary */
1249 local_bh_disable();
1250 while ((skb = __skb_dequeue(&tp->ucopy.prequeue)) != NULL)
1251 sk_backlog_rcv(sk, skb);
1252 local_bh_enable();
1253
1254 /* Clear memory counter. */
1255 tp->ucopy.memory = 0;
1256 }
先来跟踪一下tcp_prequeue_process()函数：
1240 static void tcp_prequeue_process(struct sock *sk)
1241 {
1242 struct sk_buff *skb;
1243 struct tcp_sock *tp = tcp_sk(sk);
1244
1245 NET_INC_STATS_USER(sock_net(sk), LINUX_MIB_TCPPREQUEUED);
1246
1247 /* RX process wants to run with disabled BHs, though it is not
1248 * necessary */
1249 local_bh_disable();
1250 while ((skb = __skb_dequeue(&tp->ucopy.prequeue)) != NULL)
1251 sk_backlog_rcv(sk, skb);
1252 local_bh_enable();
1253
1254 /* Clear memory counter. */
1255 tp->ucopy.memory = 0;
1256 }
618 static inline int sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)
619 {
620 return sk->sk_backlog_rcv(sk, skb); //实际回调tcp_v4_do_rcv()函数
621 }
1546 int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1547 {
1548 struct sock *rsk;
1549 #ifdef CONFIG_TCP_MD5SIG
1550 /*
1551 * We really want to reject the packet as early as possible
1552 * if:
1553 * o We‘re expecting an MD5‘d packet and this is no MD5 tcp option
1554 * o There is an MD5 option and we‘re not expecting one
1555 */
1556 if (tcp_v4_inbound_md5_hash(sk, skb))
1557 goto discard;
1558 #endif
1559
1560 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1561 TCP_CHECK_TIMER(sk);
1562 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) {
1563 rsk = sk;
1564 goto reset;
1565 }
1566 TCP_CHECK_TIMER(sk);
1567 return 0;
1568 }
1569
1570 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
1571 goto csum_err;
1572
1573 if (sk->sk_state == TCP_LISTEN) {
1574 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1575 if (!nsk)
1576 goto discard;
1577
1578 if (nsk != sk) {
1579 if (tcp_child_process(sk, nsk, skb)) {
1580 rsk = nsk;
1581 goto reset;
1582 }
1583 return 0;
1584 }
1585 }
1586
1587 TCP_CHECK_TIMER(sk);
1588 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
1589 rsk = sk;
1590 goto reset;
1591 }
1592 TCP_CHECK_TIMER(sk);
1593 return 0;
1594
1595 reset:
1596 tcp_v4_send_reset(rsk, skb);
1597 discard:
1598 kfree_skb(skb);
1599 /* Be careful here. If this function gets more complicated and
1600 * gcc suffers from register pressure on the x86, sk (in %ebx)
1601 * might be destroyed here. This current version compiles correctly,
1602 * but you have been warned.
1603 */
1604 return 0;
1605
1606 csum_err:
1607 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
1608 goto discard;
1609 }
再来看看realease_sock()函数：
1952 void release_sock(struct sock *sk)
1953 {
1954 /*
1955 * The sk_lock has mutex_unlock() semantics:
1956 */
1957 mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
1958
1959 spin_lock_bh(&sk->sk_lock.slock);
1960 if (sk->sk_backlog.tail)
1961 __release_sock(sk);
1962 sk->sk_lock.owned = 0;
1963 if (waitqueue_active(&sk->sk_lock.wq))
1964 wake_up(&sk->sk_lock.wq);
1965 spin_unlock_bh(&sk->sk_lock.slock);
1966 }
1523 static void __release_sock(struct sock *sk)
1524 {
1525 struct sk_buff *skb = sk->sk_backlog.head;
1526
1527 do {
1528 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
1529 bh_unlock_sock(sk);
1530
1531 do {
1532 struct sk_buff *next = skb->next;
1533
1534 skb->next = NULL;
1535 sk_backlog_rcv(sk, skb);
1536
1537 /*
1538 * We are in process context here with softirqs
1539 * disabled, use cond_resched_softirq() to preempt.
1540 * This is safe to do because we‘ve taken the backlog
1541 * queue private:
1542 */
1543 cond_resched_softirq();
1544
1545 skb = next;
1546 } while (skb != NULL);
1547
1548 bh_lock_sock(sk);
1549 } while ((skb = sk->sk_backlog.head) != NULL);
1550
1551 /*
1552 * Doing the zeroing here guarantee we can not loop forever
1553 * while a wild producer attempts to flood us.
1554 */
1555 sk->sk_backlog.len = 0;
1556 }
时间： 2024-11-05 16:41:47