TCP协议内存空间管理

最新推荐文章于 2024-07-15 19:18:00 发布

redwingz

最新推荐文章于 2024-07-15 19:18:00 发布

阅读量3k

点赞数 1

分类专栏： TCPIP协议文章标签： TCP tcp_mem tcp_wmem tcp_rmem

本文链接：https://blog.csdn.net/sinat_20184565/article/details/88432125

版权

TCPIP协议专栏收录该内容

105 篇文章 60 订阅

订阅专栏

PROC文件tcp_mem包括3个TCP协议内存空间的控制值，单位为页面数，如下，分别为最小空间值34524页面，承压值46032和最大值69048个页面，此三个值与系统的内存大小相关，示例为一个3G内存的Ubuntu系统。内核中对应的变量为sysctl_tcp_mem。

$ cat /proc/sys/net/ipv4/tcp_mem
34524   46032   69048
$ 
static struct ctl_table ipv4_table[] = {
    {
        .procname   = "tcp_mem",
        .maxlen     = sizeof(sysctl_tcp_mem),
        .data       = &sysctl_tcp_mem,
    },
}

TCP内存初始化

如下函数tcp_init_mem所示，TCP协议的三个内存空间控制值以系统中空闲页面总数的16分之一为基准（limit），并且此基准值又不低于128个页面。最小值为基准值的四分之三，承压值等于基准值，最大内存值等于最小值的两倍，即百分之9.375。

static void __init tcp_init_mem(void)
{
    unsigned long limit = nr_free_buffer_pages() / 16;

    limit = max(limit, 128UL);
    sysctl_tcp_mem[0] = limit / 4 * 3;      /* 4.68 % */
    sysctl_tcp_mem[1] = limit;          /* 6.25 % */
    sysctl_tcp_mem[2] = sysctl_tcp_mem[0] * 2;  /* 9.37 % */
}

另外，保存控制值的数组sysctl_tcp_mem赋值给了TCP协议结构体tcp_prot的成员sysctl_mem，以便之后需要访问控制值时，可通过sysctl_mem实现。既然需要控制TCP协议占用的内存，就需要一个变量统计当前的TCP内存占用量，见变量tcp_memory_allocated。如果其值大于承压值（sysctl_mem[1]），TCP进入内存承压状态，直到其值小于最小值（sysctl_mem[0]）时，TCP退出内存承压状态。memory_pressure变量表示是否处于内存承压状态。

atomic_long_t tcp_memory_allocated;        /* Current allocated memory. */

struct proto tcp_prot = {
    .name           = "TCP",
    .enter_memory_pressure  = tcp_enter_memory_pressure,
    .leave_memory_pressure  = tcp_leave_memory_pressure,
	.memory_allocated   = &tcp_memory_allocated,
    .memory_pressure    = &tcp_memory_pressure,
    .sysctl_mem     = sysctl_tcp_mem,
    .sysctl_wmem_offset = offsetof(struct net, ipv4.sysctl_tcp_wmem),
    .sysctl_rmem_offset = offsetof(struct net, ipv4.sysctl_tcp_rmem),
}

TCP内存占用统计

基础函数sk_memory_allocated_add，通过其调用增加TCP协议的内存占用统计值（memory_allocated成员变量同tcp_memory_allocated）。

static inline long sk_memory_allocated_add(struct sock *sk, int amt)
{
    return atomic_long_add_return(amt, sk->sk_prot->memory_allocated);
}

TCP协议最重要的内存占用统计函数为__sk_mem_raise_allocated，除了为memory_allocated变量增加amt字节的统计外，还需要进行一些列的判断，保证增加后的数值在合法范围内。sk_prot_mem_limits函数的第二个参数0、1、2分别用于获取sysctl_mem数组中的索引为0、1、2的三个TCP内存控制值。以下代码逻辑可见，增加之后的内存统计值如果小于最小控制值，退出内存承压状态并正确返回。如果大于内存承压值，则进入内存承压状态，再甚者，如果大于最大值，内核将尝试抑制本次的内存分配行为（suppress_allocation分支）。

int __sk_mem_raise_allocated(struct sock *sk, int size, int amt, int kind)
{
    struct proto *prot = sk->sk_prot;
    long allocated = sk_memory_allocated_add(sk, amt);

    /* Under limit. */
    if (allocated <= sk_prot_mem_limits(sk, 0)) {
        sk_leave_memory_pressure(sk);
        return 1;
    }
    /* Under pressure. */
    if (allocated > sk_prot_mem_limits(sk, 1))
        sk_enter_memory_pressure(sk);
    /* Over hard limit. */
    if (allocated > sk_prot_mem_limits(sk, 2))
        goto suppress_allocation;
}

在还没有达到TCP内存使用的最大值的情况下，如果TCP套接口当前已用的接收内存大小小于TCP接收缓存tcp_rmem的最小控制值（sk_get_rmem0），或者TCP套接口已用发送内存的大小小于TCP发送缓存tcp_wmem的最小控制值时（sk_get_wmem0），本次分配成功完成。

$ cat /proc/sys/net/ipv4/tcp_rmem
4096    87380   6291456
$ cat /proc/sys/net/ipv4/tcp_wmem
4096    16384   4194304

int __sk_mem_raise_allocated(struct sock *sk, int size, int amt, int kind)
{
    if (kind == SK_MEM_RECV) {
        if (atomic_read(&sk->sk_rmem_alloc) < sk_get_rmem0(sk, prot))
            return 1;
    } else { /* SK_MEM_SEND */
        int wmem0 = sk_get_wmem0(sk, prot);

        if (sk->sk_type == SOCK_STREAM) {
            if (sk->sk_wmem_queued < wmem0)
                return 1;
        } else if (refcount_read(&sk->sk_wmem_alloc) < wmem0) {
                return 1;
        }
    }
}

如果TCP内存处于承压状态（sk_under_memory_pressure），并且TCP协议当前的所有套接口数量，与发送缓存sk_wmem_queued、接收缓存sk_rmem_alloc和sk_forward_alloc三者之和的乘积，小于TCP协议的内存最大控制值，认为本次分配有效。

int __sk_mem_raise_allocated(struct sock *sk, int size, int amt, int kind)
{
    if (sk_has_memory_pressure(sk)) {

        if (!sk_under_memory_pressure(sk))
            return 1;
        alloc = sk_sockets_allocated_read_positive(sk);
        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;
    }
}

如果以上条件都未成立，则尝试取消本次分配，由函数sk_memory_allocated_sub实现。但是如果是TCP（SOCK_STREAM）的发送端（SK_MEM_SEND），并且套接口的发送缓存sk_sndbuf大于sk_wmem_queued的一半，并且大于sk_wmem_queued与当前分配缓存size值的和，分配操作正常完成。

int __sk_mem_raise_allocated(struct sock *sk, int size, int amt, int kind)
{
suppress_allocation:
    if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {
        sk_stream_moderate_sndbuf(sk);
        if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
            return 1;
    }
    sk_memory_allocated_sub(sk, amt);
}
static inline void sk_stream_moderate_sndbuf(struct sock *sk)
{
    if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK)) {
        sk->sk_sndbuf = min(sk->sk_sndbuf, sk->sk_wmem_queued >> 1);
        sk->sk_sndbuf = max_t(u32, sk->sk_sndbuf, SOCK_MIN_SNDBUF);
    }   
}

内核中对TCP内存的占用一是TCP发送端，一是接收端。发送端通过sk_wmem_schedule函数增加内存分配统计和合法性判断；接收端通过函数sk_rmem_schedule实现内存分配统计与合法性判断。对于发送端内核中的判断点，包括TCP的发送相关函数do_tcp_sendpages和tcp_sendmsg_locked，以及TCP分段函数tcp_fragment，tso_fragment和tcp_mtu_probe，tcp_send_syn_data和tcp_connect等函数。

static inline bool sk_wmem_schedule(struct sock *sk, int size)
{
    if (!sk_has_account(sk))
        return true;
    return size <= sk->sk_forward_alloc || __sk_mem_schedule(sk, size, SK_MEM_SEND);
}

对于接收端，内核中的判断点包括，接收相关函数tcp_rcv_established和sock_queue_rcv_skb函数等。

static inline bool sk_rmem_schedule(struct sock *sk, struct sk_buff *skb, int size)
{
    if (!sk_has_account(sk))
        return true;
    return size<= sk->sk_forward_alloc || __sk_mem_schedule(sk, size, SK_MEM_RECV) || skb_pfmemalloc(skb);
}

TCP内存释放统计

在TCP内存释放时，减少内存的统计值。基础函数为__sk_mem_reduce_allocated。其不仅执行了统计值的递减，而且之后判断了当前是否处于内存承压状态，若干内存使用以及降低至最小控制值，退出承压状态。

static inline void sk_memory_allocated_sub(struct sock *sk, int amt)
{
    atomic_long_sub(amt, sk->sk_prot->memory_allocated);
}
void __sk_mem_reduce_allocated(struct sock *sk, int amount)
{
    sk_memory_allocated_sub(sk, amount);

    if (sk_under_memory_pressure(sk) && (sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)))
        sk_leave_memory_pressure(sk);
}

TCP内存统计值的递减的封装函数，有sk_mem_reclaim函数，sk_mem_reclaim_partial函数和sk_mem_uncharge函数。第一个函数sk_mem_reclaim用于TCP套接口销毁之时，回收其预分配的内存配额（sk_forward_alloc），例如套接口销毁函数inet_csk_destroy_sock以及inet_sock_destruct函数对其进行调用；或者在套接口清空队列时减低内存统计值，如函数tcp_write_queue_purge对其的调用。

void __sk_mem_reclaim(struct sock *sk, int amount)
{
    amount >>= SK_MEM_QUANTUM_SHIFT;
    sk->sk_forward_alloc -= amount << SK_MEM_QUANTUM_SHIFT;
    __sk_mem_reduce_allocated(sk, amount);
}
static inline void sk_mem_reclaim(struct sock *sk)
{
    if (!sk_has_account(sk))
        return;
    if (sk->sk_forward_alloc >= SK_MEM_QUANTUM)
        __sk_mem_reclaim(sk, sk->sk_forward_alloc);
}

函数sk_mem_reclaim_partial与第一个函数基本相同，区别在于其并不回收全部的套接口预分配内存配额，仅回收了（sk->sk_forward_alloc - 1）。所有其调用之处与sk_mem_reclaim由很大的差别，例如在sk_stream_alloc_skb函数，在进行skb分配之前，如果内存处于承压状态，回收部分预分配内存，以保证接下来的内存分配能够成功完成。另外在延迟ACK定时器处理函数中（tcp_delack_timer_handler），也调用了内存部分回收函数，确保ACK的顺利发送。

static inline void sk_mem_reclaim_partial(struct sock *sk)
{
    if (sk->sk_forward_alloc > SK_MEM_QUANTUM)
        __sk_mem_reclaim(sk, sk->sk_forward_alloc - 1);
}
struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp, bool force_schedule)
{
    if (unlikely(tcp_under_memory_pressure(sk)))
        sk_mem_reclaim_partial(sk);
}

第三个函数sk_mem_uncharge，如果当前套接口的预分配内存额度大于2M字节，回收1M字节，保留太多的预分配内存额度没有必要。而且，TCP发送队列的执行流程如果没有调用sk_mem_reclaim回收内存，有可能导致超过2G的内存一次性的释放，此处减缓释放的操作。

static inline void sk_mem_uncharge(struct sock *sk, int size)
{
    sk->sk_forward_alloc += size;

    if (unlikely(sk->sk_forward_alloc >= 1 << 21))
        __sk_mem_reclaim(sk, 1 << 20);
}

对于接收缓存中的数据包，在kfree_skb函数销毁skb之时，通过sock_rfree函数调用sk_mem_uncharge减低内存统计值。对于发送缓存中（接收和重传队列）的数据包，使用函数sk_wmem_free_skb减低内存统计，并进行内存的释放操作。例如函数tcp_write_queue_purge和tcp_rtx_queue_purge函数。

void sock_rfree(struct sk_buff *skb)
{
    sk_mem_uncharge(sk, len);
}
static inline void sk_wmem_free_skb(struct sock *sk, struct sk_buff *skb)
{
    sk_mem_uncharge(sk, skb->truesize);
    __kfree_skb(skb);
}

TCP内存承压状态

是否处于内存承压状态由变量tcp_memory_pressure表示，内核使用封装函数tcp_under_memory_pressure来判断内存是否承压。另外，TCP函数tcp_enter_memory_pressure和tcp_leave_memory_pressure函数分别在进入和退出承压状态时调用，进入承压状态时，tcp_memory_pressure变量记录下当前时间，在退出承压状态时，计算TCP处于承压状态的时长，保存在当前网络命名空间的统计信息中。

unsigned long tcp_memory_pressure __read_mostly;
static inline bool tcp_under_memory_pressure(const struct sock *sk)
{
    return tcp_memory_pressure;
}

如前对函数__sk_mem_raise_allocated的描述，在当前的TCP内存使用值超过设定的承压值时，进入承压状态，当小于设定的最小值时，退出承压状态。函数__sk_mem_raise_allocated的两个封装函数sk_wmem_schedule和sk_rmem_schedule，分别用于在TCP发送路径和接收路径上统计和控制内存使用情况。

发送路径上的函数由诸如：tcp_sendmsg_locked，do_tcp_sendpages和通用的发送skb分配函数sk_stream_alloc_skb。如下，在skb分配成功之后，增加内存使用统计值，反之，分配失败的话进入内存承压状态。有一点需要注意，即使skb分配成功，如果在随后的sk_wmem_schedule函数中的判断中，新分配的内存空间致使内存使用量超过限制，还是会导致分配失败，释放掉分配好的skb缓存。

struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp, bool force_schedule)
{
    skb = alloc_skb_fclone(size + sk->sk_prot->max_header, gfp);
    if (likely(skb)) {
        if (force_schedule) {
        } else {
            mem_scheduled = sk_wmem_schedule(sk, skb->truesize);
        }
        if (likely(mem_scheduled)) {
            return skb;
        }
        __kfree_skb(skb);
    } else {
        sk->sk_prot->enter_memory_pressure(sk);
    }
}

接收路径上的函数诸如：__sock_queue_rcv_skb函数，tcp_data_queue_ofo和tcp_data_queue函数。如下为tcp_data_queue函数，在接收到TCP数据包之后，检查增加此数据包长度后TCP的内存占用是否超限，超限的话丢弃数据包。

static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
{
    struct tcp_sock *tp = tcp_sk(sk);
	
    if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {
        /* Ok. In sequence. In window. */
queue_and_out:
        if (skb_queue_len(&sk->sk_receive_queue) == 0)
            sk_forced_mem_schedule(sk, skb->truesize);
        else if (tcp_try_rmem_schedule(sk, skb, skb->truesize))
            goto drop;
    }
}

最后，在发送路径上，当套接口中的页面不足以存放数据包分片时，进入内存承压状态。如下函数__ip_append_data所示，只有当数据包的出口设备支持分散/聚集（NETIF_F_SG）特性时，才会执行此流程。

bool sk_page_frag_refill(struct sock *sk, struct page_frag *pfrag)
{               
    if (likely(skb_page_frag_refill(32U, pfrag, sk->sk_allocation)))
        return true;

    sk_enter_memory_pressure(sk);
}
static int __ip_append_data(struct sock *sk, struct flowi4 *fl4, struct sk_buff_head *queue, ...)
{
    while (length > 0) {
        if (!(rt->dst.dev->features&NETIF_F_SG)) {
        } else {
            int i = skb_shinfo(skb)->nr_frags;
            if (!sk_page_frag_refill(sk, pfrag))
                goto error;
		}
	}
}

TCP内存超限

除了以上介绍的__sk_mem_raise_allocated函数之外，tcp_out_of_memory函数也用于TCP内存超过设定的最大值的判断。sk_prot_mem_limits函数第二个参数为2表示获取出设定的TCP内存最大限值。其被函数tcp_check_oom所封装，如果TCP当前内存超限，内核会有打印信息输出到终端上。

static inline bool tcp_out_of_memory(struct sock *sk)
{
    if (sk->sk_wmem_queued > SOCK_MIN_SNDBUF && sk_memory_allocated(sk) > sk_prot_mem_limits(sk, 2))
        return true;
    return false;
}
bool tcp_check_oom(struct sock *sk, int shift)
{
    out_of_socket_memory = tcp_out_of_memory(sk);
    if (out_of_socket_memory)
        net_info_ratelimited("out of memory -- consider tuning tcp_mem\n");
    return  out_of_socket_memory;
}

在函数tcp_close函数和一系列的TCP定时器函数如tcp_write_timeout和tcp_probe_timer中检测TCP的OOM情况。以上定时器函数通过调用tcp_out_of_resources，间接调用tcp_check_oom函数。

TCP内存分配的特例

在特定的情况下，内核允许TCP内存的分配不受内存限额的约束。参见以下函数sk_forced_mem_schedule，与之上函数__sk_mem_raise_allocated不同，其直接增加内存的分配统计，不考虑任何的超限情况。

void sk_forced_mem_schedule(struct sock *sk, int size)
{
    if (size <= sk->sk_forward_alloc)
        return;
    amt = sk_mem_pages(size);
    sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
    sk_memory_allocated_add(sk, amt);
}

特定的情况包括，TCP的FIN报文发送等，内核尽可能的保证FIN报文的成功发送，以便尽快的结束一个TCP连接。

void tcp_send_fin(struct sock *sk)
{
    struct sk_buff *skb, *tskb = tcp_write_queue_tail(sk);

    if (tskb) {
    } else {
        skb = alloc_skb_fclone(MAX_TCP_HEADER, sk->sk_allocation);
        sk_forced_mem_schedule(sk, skb->truesize);
    }
}

另外，在TCP套接口接收到一个正常序号的数据包，并且其位于接收窗口之内，而此时的接收队列又是为空，内核强制增加内存的统计值，以保证其正确接收。这样可避免对端无谓的重传，但是又能保护TCP的内存不至于超限被过度使用（接收队列为空判断时执行）。在函数tcp_data_queue中，与以上tcp_send_fin不同，内核仅增加内存统计值，并未实际分配内存，数据包skb内存由网卡驱动程序分配而来。

static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
{
    struct tcp_sock *tp = tcp_sk(sk);

    if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {
        /* Ok. In sequence. In window. */
queue_and_out:
        if (skb_queue_len(&sk->sk_receive_queue) == 0)
            sk_forced_mem_schedule(sk, skb->truesize);
	}
}

再者，在TCP分配内存时，可通过参数force_schedule指定强制增加内存统计，不受限定值约束。目前在内核中TCP分片相关函数tcp_fragment和tso_fragment，TCP连接发起函数tcp_connect在使用此强制选项，这些函数的alloc_skb_fcone操作不受限定值约束，只要系统内存做够，即可分配成功。

struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp, bool force_schedule)
{
    skb = alloc_skb_fclone(size + sk->sk_prot->max_header, gfp);
    if (likely(skb)) {
        if (force_schedule) {
            mem_scheduled = true;
            sk_forced_mem_schedule(sk, skb->truesize);
        }
    }
}

最后，在TCP发送函数，无论是do_tcp_sendpages还是tcp_sendmsg_locked函数中，在TCP的重传队列和发送队列都为空的情况下，即tcp_rtx_and_write_queues_empty为真，说明发送缓冲区都已清空，可强制进行内存分配，并增加内存统计。

ssize_t do_tcp_sendpages(struct sock *sk, struct page *page, int offset, size_t size, int flags)
{
    while (size > 0) {
        struct sk_buff *skb = tcp_write_queue_tail(sk);

        if (!skb || (copy = size_goal - skb->len) <= 0 || !tcp_skb_can_collapse_to(skb))
            skb = sk_stream_alloc_skb(sk, 0, sk->sk_allocation, tcp_rtx_and_write_queues_empty(sk));
} 
int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size)
{
    while (msg_data_left(msg)) {
        if (copy <= 0 || !tcp_skb_can_collapse_to(skb)) {
            first_skb = tcp_rtx_and_write_queues_empty(sk);
            skb = sk_stream_alloc_skb(sk, select_size(sk, sg, first_skb), sk->sk_allocation, first_skb);
		}
	}
}

TCP内存承压与超限的影响

如函数sk_stream_alloc_skb所示，在内存承压之后，内核开始回收已分配的内存。并且停止TCP内存分配相关的操作。

struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp, bool force_schedule)
{
    if (unlikely(tcp_under_memory_pressure(sk)))
        sk_mem_reclaim_partial(sk);
}

如FIN报文发送函数tcp_send_fin，在进入内存承压状态后，试图避免单独的FIN报文分配，将FIN标志设置到重传队列的最后一个数据包上。

void tcp_send_fin(struct sock *sk)
{
    struct sk_buff *skb, *tskb = tcp_write_queue_tail(sk);

    if (!tskb && tcp_under_memory_pressure(sk))
        tskb = skb_rb_last(&sk->tcp_rtx_queue);
}

另外，停止TCP接收窗口的增长，以及停止发送缓存的增长。

static void tcp_grow_window(struct sock *sk, const struct sk_buff *skb)
{
    struct tcp_sock *tp = tcp_sk(sk);
    if (tp->rcv_ssthresh < tp->window_clamp && (int)tp->rcv_ssthresh < tcp_space(sk) &&
        !tcp_under_memory_pressure(sk)) {
    } 
}
static bool tcp_should_expand_sndbuf(const struct sock *sk)
{
    if (tcp_under_memory_pressure(sk))
        return false;
    if (sk_memory_allocated(sk) >= sk_prot_mem_limits(sk, 0))
        return false;
}

再者，对于TCP的接收路径，如果内存处于承压状态，丢掉进入的数据包不在接收。对于发送端函数，诸如tcp_sendmsg_locked或者do_tcp_sendpages函数，在内存承压时，可进入等待队列，即函数sk_stream_wait_memory等待内存可用。内存可用时内核使用函数sk_stream_write_space唤醒等待的队列。

static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
{
    if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {
queue_and_out:
        if (skb_queue_len(&sk->sk_receive_queue) == 0)
            sk_forced_mem_schedule(sk, skb->truesize);
        else if (tcp_try_rmem_schedule(sk, skb, skb->truesize))
            goto drop;
}
int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size)
{
    while (msg_data_left(msg)) {
        if (skb_availroom(skb) > 0) {
        } else if (!uarg || !uarg->zerocopy) {
            if (!sk_page_frag_refill(sk, pfrag))
                goto wait_for_memory;
            if (!sk_wmem_schedule(sk, copy))
                goto wait_for_memory;
		}
wait_for_memory:
        err = sk_stream_wait_memory(sk, &timeo);
    }
}

PROC文件protocols

PROC文件/proc/net/protocols可查看当前各个协议包括TCP的内存使用情况，已经承压状态，如下所示：

$ cat /proc/net/protocols 
protocol  size sockets  memory press maxhdr  slab module     cl co di ac io in de sh ss gs se re sp bi br ha uh gp em
TCPv6     2152      2       1   no     304   yes  kernel      y  y  y  y  y  y  y  y  y  y  y  y  y  n  y  y  y  y  y
RAW        928      0      -1   NI       0   yes  kernel      y  y  y  n  y  y  y  n  y  y  y  y  n  y  y  y  y  n  n
UDP        984      5       5   NI       0   yes  kernel      y  y  y  n  y  y  y  n  y  y  y  y  y  n  n  y  y  y  n
TCP       1992      9       1   no     304   yes  kernel      y  y  y  y  y  y  y  y  y  y  y  y  y  n  y  y  y  y  y

内核版本 4.15.0