TCP的发送系列 — 发送缓存的管理（二）

主要内容：从TCP层面判断发送缓存的申请是否合法，进程因缺少发送缓存而进行睡眠等待、

                    因为有发送缓存可写事件而被唤醒。

内核版本：3.15.2

我的博客：http://blog.csdn.net/zhangskd

 

TCP的发送缓存管理发生在两个层面上：单个Socket和整个TCP层。

上一篇blog讲述了单个Socket层面上的发送缓存管理，现在来看下整个TCP层面上的发送缓存管理。

 

从TCP层面判断发送缓存的申请是否合法

 

在申请发送缓存时，会调用sk_stream_memory_free()来判断sock发送队列的大小是否超过

了sock发送缓存的上限，如果超过了，就要进入睡眠来等待sock的发送缓存可写事件。

这是从单个socket层面来判断是否允许分配发送缓存。

 

在调用sk_stream_alloc_skb()申请完发送缓存后，还要从TCP层面来判断此次的申请是否合法。

如果不合法，就使用__kfree_skb()来释放申请好的skb。可见发送缓存的申请，需要经过两重关卡。

 

从TCP层面来判断发送缓存的申请是否合法，需要考虑整个TCP层面的内存使用量，以及此socket

的发送缓存使用量。sk->sk_forward_alloc为sock预分配缓存的大小，是sock事先分配好还未使用的内存。

当申请新的发送缓存后，如果发现sk->sk_forward_alloc < skb->truesize，即预分配缓存用光了，

才需要调用sk_wme_schedule()来从TCP层面判断合法性，否则不用再做检查。

static inline bool sk_wmem_schedule(struct sock *sk, int size)
{
    /* TCP层是有统计内存使用的，所以条件为假 */
    if (! sk_has_account(sk))
        return true;

    /* 如果本次使用的内存skb->truesize，少于sk预分配且未使用的缓存的大小，那么不用进行
     * 进一步检查。否则需要从TCP层面判断此次发送缓存的申请是否合法。
     */
    return size <= sk->sk_forward_alloc || __sk_mem_schedule(sk, size, SK_MEM_SEND);
}

static inline bool sk_has_account(struct sock *sk)
{
    /* return ture if protocol supports memory accounting */
    return !! sk->sk_prot->memory_allocated;
}
 

/* return minimum truesize of one skb containing X bytes of data */
#define SKB_TRUESIZE(X) ((X) + \
    SKB_DATA_ALIGN(sizeof(struct sk_buff)) + \
    SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))

 

__sk_mem_schedule()用来从TCP层面判断此次发送缓存的申请是否合法，如果是合法的，

会更新预分配缓存sk->sk_forward_alloc和TCP层总的内存使用量tcp_memory_allocated，

后者的单位为页。

 

Q：哪些情况下此次发送缓存的申请是合法的呢？

1. TCP层的内存使用量低于最小值sysctl_tcp_mem[0]。

2. sock的发送缓存使用量低于最小值sysctl_tcp_wmem[0]。

3. TCP层不处于内存压力状态，即TCP层的内存使用量低于sysctl_tcp_wmem[1]。

4. TCP层处于内存压力状态，但当前socket使用的内存还不是太高。

5. TCP层的内存使用量超过最大值sysctl_tcp_wmem[2]，降低发送缓存的上限后，发送队列的总大小超过

    了发送缓存的上限了。因此之后会进入睡眠等待，所以也判为合法的。

 

可以看到，在绝大多数情况下发送缓存的申请都是合法的，除非TCP的内存使用量已经到极限了。

除了判断此次发送缓存申请的合法性，__sk_mem_schedule()还做了如下事情：

1. 如果TCP的内存使用量低于最小值sysctl_tcp_mem[0]，就清零TCP的内存压力标志tcp_memory_pressure。

2. 如果TCP的内存使用量高于压力值sysclt_tcp_mem[1]，把TCP的内存压力标志tcp_memory_pressure置为1。

3. 如果TCP的内存使用量高于最大值sysctl_tcp_mem[2]，就减小sock发送缓存的上限sk->sk_sndbuf。

 

返回值为1时，表示发送缓存的申请是合法的；返回值为0时，表示不合法。

/* increase sk_forward_alloc and memory_allocated
 * @sk: socket
 * @size: memory size to allocate
 * @kind: allocation type
 * If kind is SK_MEM_SEND, it means wmem allocation.
 * Otherwise it means rmem allocation. This function assumes that 
 * protocols which have memory pressure use sk_wmem_queued as
 * write buffer accounting.
 */

int __sk_mem_schedule(struct sock *sk, int size, int kind)
{
    struct proto *prot = sk->sk_prot; /* 实例为tcp_prot */
    int amt = sk_mem_pages(size); /* 把size转换为页数，向上取整 */
    long allocated;
    int parent_status = UNDER_LIMIT;

    sk->sk_forward_alloc += amt * SK_MEM_QUANTUM; /* 更新预分配缓存的大小 */

    /* 更新后的TCP内存使用量tcp_memory_allocated，单位为页 */
    allocated = sk_memory_allocated_add(sk, amt, &parent_status);

    /* Under limit. 如果TCP的内存使用量低于最小值sysctl_tcp_mem[0] */
    if (parent_status == UNDER_LIMIT && allocated <= sk_prot_mem_limits(sk, 0)) {
        sk_leave_memory_pressure(sk); /* 清零TCP层的内存压力标志tcp_memory_pressure */
        return 1;
    }

    /* Under pressure. (we or our parents).
     * 如果TCP的内存使用量高于压力值sysclt_tcp_mem[1]，把TCP层的内存压力标志
     * tcp_memory_pressure置为1。
     */
    if ((parent_status > SOFT_LIMIT) || allocated > sk_prot_mem_limits(sk, 1))
        sk_enter_memory_pressure(sk);

    /* Over hard limit (we or our parents).
     * 如果TCP层的内存使用量高于最大值sysctl_tcp_mem[2]，就减小sock发送缓存的上限
     * sk->sk_sndbuf。
     */
    if ((parent_status == OVER_LIMIT || (allocated > sk_prot_mem_limits(sk, 2)))
        goto suppress_allocation;

    /* guarantee minimum buffer size under pressure */
    /* 不管是在发送还是接收时，都要保证sock至少有sysctl_tcp_{r,w}mem[0]的内存可用 */
    if (kind == SK_MEM_RECV) {
        if (atomic_read(&sk->sk_rmem_alloc) < prot->sysctl_rmem[0])
            return 1;

    } else { /* SK_MEM_SEND */
        if (sk->sk_type == SOCK_STREAM) {
            if (sk->sk_wmem_queued < prot->sysctl_wmem[0])
                return 1;
        } else if (atomic_read(&sk->sk_wmem_alloc) < prot->sysctl_wmem[0])
            return 1;
    }

   if (sk_has_memory_pressure(sk)) {
        int alloc;

        /* 如果TCP不处于内存压力状态，直接返回 */
        if (! sk_under_memory_pressure(sk))
            return 1;

        alloc = sk_sockets_allocated_read_positive(sk); /* 当前使用TCP的socket个数 */

        /* 如果当前socket使用的内存还不是太高时，返回真 */
        if (sk_prot_mem_limits(sk, 2) > alloc * sk_mem_pages(sk->sk_wmem_queued +
             atomic_read(&sk->sk_rmem_alloc) + sk->sk_forward_alloc))
            return 1;
    }

suppress_allocation:
    if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {

        /* 减小sock发送缓冲区的上限，使得sndbuf不超过发送队列总大小的一半，
         * 不低于两个数据包的MIN_TRUESIZE。
         */
        sk_stream_moderate_sndbuf(sk); 

        /* Fail only if socket is under its sndbuf.
         * In this case we cannot block, so that we have to fail.
         */
        if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
            return 1;
    } 
    trace_sock_exceed_buf_limit(sk, prot, allocated);
 
    /* 走到这里，判定此次发送缓存的申请为不合法的，撤销之前的内存计数更新 */
    /* Alas. Undo changes. */
    sk->sk_forward_alloc -= amt * SK_MEM_QUANTUM;
    sk_memory_allocated_sub(sk, amt);
    return 0;
}

/* 把字节数amt转换为页数，向上取整 */
static inline int sk_mem_pages(int amt)
{
    return (amt + SK_MEM_QUANTUM - 1) >> SK_MEM_QUANTUM_SHIFT;
}
#define SK_MEM_QUANTUM ((int) PAGE_SIZE)

/* 返回更新后的TCP内使用量tcp_memory_allocated，单位为页 */
static inline long sk_memory_allocated_add(struct sock *sk, int amt, int *parent_status)
{
    struct proto *prot = sk->sk_prot;

    /* Cgroup相关，此处略过 */
    if (mem_cgroup_sockets_enabled && sk->sk_cgrp) {
        ...
    }

    return atomic_long_add_return(amt, prot->memory_allocated);
}

sysctl_tcp_mem[0]：最小值

sysctl_tcp_mem[1]：压力值

sysctl_tcp_mem[2]：最大值

static inline long sk_prot_mem_limits(const struct sock *sk, int index)
{
    long *prot = sk->sk_prot->sysctl_mem;

    /* Cgroup相关 */
    if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
        prot = sk->sk_cgrp->sysctl_mem;

    return prot[index];
}

 

因缺少发送缓存而睡眠等待

 

在tcp_sendmsg()中，如果发送队列的总大小sk_wmem_queued大于等于发送缓存的上限sk_sndbuf，

或者发送缓存中尚未发送的数据量超过了用户的设置值，就进入睡眠等待。

如果申请发送缓存失败了，也会进行睡眠等待。

 

(1) 判断条件

sk_stream_memory_free()用来判断sock是否有剩余的发送缓存。

static inline bool sk_stream_memory_free(const struct sock *sk)
{
    if (sk->sk_wmem_queued >= sk->sk_sndbuf)
        return false;

    return sk->sk_prot->stream_memory_free ? sk->sk_prot->stream_memory_free(sk) : true;
}

static inline bool tcp_stream_memory_free(const struct sock *sk)
{
    const struct tcp_sock *tp = tcp_sk(sk);
    u32 notsent_bytes = tp->write_seq - tp->snd_nxt; /* 尚未发送的数据大小 */

    /* 当尚未发送的数据，少于配置的值时，才返回真。
     * 这是为了避免发送缓存占用过多的内存。
     */
    return notsent_bytes < tcp_notsent_lowat(tp);
}

如果有使用TCP_NOTSENT_LOWAT选项，则使用用户设置的值。

否则使用sysctl_tcp_notsent_lowat，默认为无穷大。

static inline u32 tcp_notsent_lowat(const struct tcp_sock *tp)
{
    return tp->notsent_lowat ?: sysctl_tcp_notsent_lowat;
}

 

(2) 睡眠等待

如果发送队列的总大小sk_wmem_queued大于等于发送缓存的上限sk_sndbuf，

或者发送缓存中尚未发送的数据量超过了用户的设置，就进入等待。

如果因为TCP层的内存不足，导致申请发送缓存失败了，也会进行睡眠等待。

 

Q：需要睡眠等待多长的时间呢？

需要分两种情况：

1. 等待的原因是TCP层的内存不足。

    刚进入函数时，会判断sock的发送缓存是否达到了上限。

    如果此时sock尚有发送缓存额度，说明是TCP层内存不足导致发送缓存申请失败的，

    设置等待时间为一个2~202ms的伪随机数，超时后就结束等待。

2. 等待的原因是sock的发送缓存不足。

    在睡眠的过程中，当有可用的发送缓存时，进程会被唤醒，从而结束等待。

    否则达到超时时间后，返回错误。

/* Wait for more memory for a socket
 * @sk: socket to wait for memory
 * @timeo_p: for how long
 */

int sk_stream_wait_memory(struct sock *sk, long *timeo_p)
{
    int err = 0;
    long vm_wait = 0;
    long current_timeo = *timeo_p;
    DEFINE_WAIT(wait); /* 初始化等待任务 */

    /* 如果sock还有发送缓存额度，说明是TCP层内存不足导致的。
     * 初始化等待时间为一个2~202ms的伪随机数。
     */
    if (sk_stream_memory_free(sk))
        current_timeo = vm_wait = (prandom_u32() % (HZ / 5)) + 2;

    while (1) {
        /* 设置异步发送时，发送缓存不够的标志 */
        set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);

        /* 把等待任务加入到socket等待队列头部，把进程的状态设为TASK_INTERRUPTIBLE */
        prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);

        /* 如果连接有错误，或者不允许发送数据了，那么返回-EPIPE */
        if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
            goto do_error;

        /* 如果是非阻塞的，或者等待超时了，返回-EAGAIN */
        if (! *timeo_p)
            goto do_nonblock;

        /* 如果进程有待处理的信号，如果没有设置超时时间返回-ERESTARTSYS，
         * 否则返回-EINTR.
         */
        if (signal_pending(current))
            goto do_interrupte;
 
        clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);

        /* 如果sock已经有可用的发送缓存了。并满足以下任一条件：
         * 1. 此次等待是由于sock的发送缓存不足。 
         * 2. 此次等待是由于TCP层内存不足，经过了一次睡眠vm_wait设为0。 
         */
        if (sk_stream_memory_free(sk) && ! vm_wait)
            break;
 
        set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
        sk->sk_write_pending++;

        /* 进入睡眠等待 */
        sk_wait_event(sk, ¤tt_timeo, sk->sk_err ||
            (sk->sk_shutdown & SEND_SHUTDOWN) || 
            (sk_stream_memory_free(sk) && ! vm_wait)); 
        sk->sk_write_pending--;

        /* 如果vm_wait不为0，睡眠2~202ms后，就把vm_wait清零了 */
        if (vm_wait) {
            vm_wait -= current_timeo;
            current_timo = *timeo_p;

            if (current_timeo != MAX_SCHEDULE_TIMEOUT &&
                (current_timeo -= vm_wait) < 0)
                current_timeo = 0;

            vm_wait = 0;
        }

        *timeo_p = current_timeo; /* 更新发送的超时等待时间 */
    }

out:
    /* 把等待任务从等待队列中删除，把当前进程的状态设为TASK_RUNNING */
    finish_wait(sk_sleep(sk), &wait);
    return err;

do_error:
    err = -EPIPE;
    goto out;

do_nonblock:
    err = -EAGAIN;
    goto out;

do_interrupted:
    err = sock_intr_errno(*timeo_p);
    goto out;
}

 

因有发送缓存可写事件而被唤醒

 

sk->sk_write_space的实例为sock_def_write_space()。

如果socket是SOCK_STREAM类型的，那么函数指针的值会更新为sk_stream_write_space()。

sk_stream_write_space()在TCP中的调用路径为：

tcp_rcv_established / tcp_rcv_state_process

    tcp_data_snd_check

        tcp_check_space

            tcp_new_space

static void tcp_check_space(struct sock *sk)
{
    /* 如果发送队列中有skb被释放了 */
    if (sock_flag(sk, SOCK_QUEUE_SHRUNK)) {

        sock_reset_flag(sk, SOCK_QUEUE_SHRUNK);

        /* 如果设置了同步发送时，发送缓存不足的标志 */
        if (sk->sk_socket && test_bit(SOCK_NOSPACE, &sk->sk_socket->flags))
            tcp_new_space(sk); /* 更新发送缓存 */
    }
}

/* When incoming ACK allowed to free some skb from write_queue,
 * we remember this event in flag SOCK_QUEUE_SHRUNK and wake up socket
 * on the exit from tcp input handler.
 */
static void tcp_new_space(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);

    if (tcp_should_expand_sndbuf(sk)) {
        tcp_sndbuf_expand(sk);
        tp->snd_cwnd_stamp = tcp_time_stamp;
    }

    /* 检查是否需要触发有缓存可写事件 */
    sk->sk_write_space(sk);
}

void sk_stream_write_space(struct sock *sk)
{
    struct socket *sock = sk->sk_socket;
    struct socket_wq *wq; /* 等待队列和异步通知队列 */

    /* 如果剩余的发送缓存不低于发送缓存上限的1/3，且尚未发送的数据不高于一定值时 */
    if (sk_stream_is_writeable(sk) && sock) {
        clear_bit(SOCK_NOSPACE, &sock->flags); /* 清除发送缓存不够的标志 */

        rcu_read_lock();
        wq = rcu_dereference(sk->sk_wq); /* socket的等待队列和异步通知队列 */
        if (wq_has_sleeper(wq)) /* 如果等待队列不为空，则唤醒一个睡眠进程 */
            wake_up_interruptible_poll(&wq->wait, POLLOUT | POLLWRNORM | POLLWRBAND);

        /* 异步通知队列不为空，且允许发送数据时。
         * 检测sock的发送队列是否曾经到达上限，如果有的话发送SIGIO信号，告知异步通知队列上
         * 的进程有发送缓存可写。
         */
        if (wq && wq->fasync_list && !(sk->sk_shutdown & SEND_SHUTDOWN))
            sock_wake_async(sock, SOCK_WAKE_SPACE, POLL_OUT);

        rcu_read_unlock();
    }
}

#define wake_up_interruptible_poll(x, m) \
    __wake_up(x, TASK_INTERRUPTIBLE, 1, (void *) (m))

如果剩余的发送缓存大于发送缓存上限的1/3，且尚未发送的数据少于一定值时，才会触发有发送

缓存可写的事件。

static inline bool sk_stream_is_writeable(const struct sock *sk)
{
    return sk_stream_wspace(sk) >= sk_stream_min_wspace(sk) &&
        sk_stream_memory_free(sk);
}

static inline int sk_stream_wspace(const struct sock *sk)
{
    return sk->sk_sndbuf - sk->sk_wmem_queued;
}

static inline int sk_stream_min_wspace(const struct sock *sk)
{
    return sk->sk_wmem_queued >> 1;
}

检查尚未发送的数据是否已经够多了，如果超过了用户设置的值，就不用触发有发送缓存可写事件，

以免使用过多的内存。

static inline bool sk_stream_memory_free(const struct sock *sk)
{
    if (sk->sk_wmem_queued >= sk->sk_sndbuf)
        return false;

    return sk->sk_prot->stream_memory_free ? sk->sk_prot->stream_memory_free(sk) : true;
}

static inline bool tcp_stream_memory_free(const struct sock *sk)
{
    const struct tcp_sock *tp = tcp_sk(sk);
    u32 notsent_bytes = tp->write_seq - tp->snd_nxt; /* 尚未发送的数据大小 */

    /* 当尚未发送的数据，少于配置的值时，才触发有发送缓存可写的事件。
     * 这是为了避免发送缓存占用过多的内存。
     */
    return notsent_bytes < tcp_notsent_lowat(tp);
}

如果有使用TCP_NOTSENT_LOWAT选项，则使用用户设置的值。

否则使用sysctl_tcp_notsent_lowat，默认为无穷大。

static inline u32 tcp_notsent_lowat(const struct tcp_sock *tp)
{
    return tp->notsent_lowat ?: sysctl_tcp_notsent_lowat;
}

 

 

转载于:https://www.cnblogs.com/aiwz/p/6333229.html