linux网桥处理函数学习------br_handle_frame_finish

最新推荐文章于 2022-04-08 17:28:45 发布
最新推荐文章于 2022-04-08 17:28:45 发布
阅读量2.6k 收藏 3
点赞数 1
分类专栏： linux-网桥 文章标签： linux网桥
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jackywgw/article/details/78297514
版权 

/* note: already called with rcu_read_lock */
int br_handle_frame_finish(struct sock *sk, struct sk_buff *skb)
{
    const unsigned char *dest = eth_hdr(skb)->h_dest;
    struct net_bridge_port *p = br_port_get_rcu(skb->dev);
    struct net_bridge *br;
    struct net_bridge_fdb_entry *dst;
    struct net_bridge_mdb_entry *mdst;
    struct sk_buff *skb2;
    bool unicast = true;
    u16 vid = 0;
    /*如果桥接口不存在，或者stp状态为disable，丢弃报文*/
    if (!p || p->state == BR_STATE_DISABLED)
        goto drop;

    /*对vlan做相关判断，默认直接返回true*/
    if (!br_allowed_ingress(p->br, nbp_get_vlan_info(p), skb, &vid))
        goto out;

#if defined(CONFIG_BCM_KF_VLAN_AGGREGATION) && defined(CONFIG_BCM_VLAN_AGGREGATION)
#if defined(CONFIG_BCM_KF_VLAN) && (defined(CONFIG_BCM_VLAN) || defined(CONFIG_BCM_VLAN_MODULE))
    if (skb->vlan_count)
        vid = (skb->vlan_header[0] >> 16) & VLAN_VID_MASK;
    else
#endif /* CONFIG_BCM_VLAN) */
    /* 
    *  dev.c/__netif_receive_skb(): if proto == ETH_P_8021Q
    *  call vlan_untag() to remove tag and save vid in skb->vlan_tci
    */
    /*从skb中获取vlan id*/
#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0))
    if (vlan_tx_tag_present(skb))
#else
    if (skb_vlan_tag_present(skb))
#endif
        vid = skb->vlan_tci & VLAN_VID_MASK;
    else if ( vlan_eth_hdr(skb)->h_vlan_proto == htons(ETH_P_8021Q) )
        vid = ntohs(vlan_eth_hdr(skb)->h_vlan_TCI) & VLAN_VID_MASK;
#endif

    /* insert into forwarding database after filtering to avoid spoofing */
    br = p->br; /*获取网桥结构*/
    if (p->flags & BR_LEARNING)  /*如果网桥使能了mac学习的功能，则根据源mac地址更新mac转发表*/
        br_fdb_update(br, p, eth_hdr(skb)->h_source, vid, false);

    /*组播报文的igmp处理*/
    if (!is_broadcast_ether_addr(dest) && is_multicast_ether_addr(dest) &&
        br_multicast_rcv(br, p, skb, vid))
        goto drop;

    /*更新完mac转发表，如果端口还是处理stp学习状态，这个报文就此drop掉*/
#if defined(CONFIG_BCM_KF_WL)     
    if ((p->state == BR_STATE_LEARNING) &&
        (skb->protocol != htons(0x886c) /*ETHER_TYPE_BRCM*/) &&
        (skb->protocol != htons(0x888e) /*ETHER_TYPE_802_1X*/) &&
        (skb->protocol != htons(0x88c7) /*ETHER_TYPE_802_1X_PREAUTH*/))
#else
    if (p->state == BR_STATE_LEARNING)
#endif
        goto drop;

    /*在skb中记录网桥设备*/
    BR_INPUT_SKB_CB(skb)->brdev = br->dev;

    /* The packet skb2 goes to the local host (NULL to skip). */
    skb2 = NULL;
    /*判断网卡是否处于混杂模式*/
    if (br->dev->flags & IFF_PROMISC)
        skb2 = skb;

    dst = NULL;
    /*处理arp代理*/
    if (IS_ENABLED(CONFIG_INET) && skb->protocol == htons(ETH_P_ARP))
        br_do_proxy_arp(skb, br, vid, p);

#if (defined(CONFIG_BCM_MCAST) || defined(CONFIG_BCM_MCAST_MODULE)) && defined(CONFIG_BCM_KF_MCAST)
    if ( br_bcm_mcast_receive != NULL )
    {
        int rv = br_bcm_mcast_receive(br->dev->ifindex, skb, 0);
        if ( rv < 0 )
        {
            /* there was an error with the packet */
            goto drop;
        }
        else if ( rv > 0 )
        {
            /* the packet was consumed */
            goto out;
        }
        /* continue */
    }
#endif
    /*广播报文*/
    if (is_broadcast_ether_addr(dest)) {
#if defined(CONFIG_BCM_KF_EXTSTATS)
    {
        br->dev->stats.rx_broadcast_packets++;
#endif
        skb2 = skb;
#if defined(CONFIG_BCM_KF_EXTSTATS)
    }                                     
#endif
        unicast = false;
    } else if (is_multicast_ether_addr(dest)) {
        mdst = br_mdb_get(br, skb, vid);
        if ((mdst || BR_INPUT_SKB_CB_MROUTERS_ONLY(skb)) &&
            br_multicast_querier_exists(br, eth_hdr(skb))) {
            if ((mdst && mdst->mglist) ||
                br_multicast_is_router(br))
                skb2 = skb;
            br_multicast_forward(mdst, skb, skb2);
            skb = NULL;
            if (!skb2)
                goto out;
        } else
            skb2 = skb;

        unicast = false;
        br->dev->stats.multicast++;
#if defined(CONFIG_BCM_KF_EXTSTATS)
        br->dev->stats.rx_multicast_bytes += skb2->len;
#endif
#if !(defined(CONFIG_BCM_KF_BLOG) && defined(CONFIG_BLOG))
    } else if ((dst = __br_fdb_get(br, dest, vid)) &&
            dst->is_local) {
        skb2 = skb;
        /* Do not forward the packet since it's local. */
        skb = NULL;
    }
#else
    } else {
        struct net_bridge_fdb_entry *src;

        dst = __br_fdb_get(br, dest, vid);
        src = __br_fdb_get(br, eth_hdr(skb)->h_source, vid);
        blog_lock();
        if (src)
            blog_link(BRIDGEFDB, blog_ptr(skb), (void*)src, BLOG_PARAM1_SRCFDB, 0);

        if (dst)
            blog_link(BRIDGEFDB, blog_ptr(skb), (void*)dst, BLOG_PARAM1_DSTFDB, 0);

        blog_unlock();

......
......
        /*如果在mac转发表中找到表项，并且是本地的，设置skb2=skb,skb = NULL*/
        if ((dst != NULL) && dst->is_local) {   
            skb2 = skb;
            /* Do not forward the packet since it's local. */
            skb = NULL;
        }
    }
#endif

/*1. fdb 表中存在表项且是本地端口或者组播处理完成，设置 skb2 = skb, skb = null, unicast = false, dst != null
  2. 广播或者组播未处理完成 skb2 = skb, skb != null, unicast = false, dst = null
  3. fdb表中不存在表项（未知单播），skb2 = null, skb != null, unicast = true， dst = null
  4. fdb表中找到表项但不是本地端口， skb2 = null, skb != null, unicast = true, dst != null*/
    if (skb) {
        if (dst) {
            /*转发表中存在并且不是本地的，即需要转发到其它端口*/
            dst->used = jiffies;
            br_forward(dst->dst, skb, skb2);
        } else
#if defined(CONFIG_BCM_KF_FBOND) && (defined(CONFIG_BCM_FBOND) || defined(CONFIG_BCM_FBOND_MODULE))
            if (BR_STATE_BLOCKING == p->state)
                /* prevent flooding unknown unicast from blocked port */
                goto drop;
            else
#endif
            /*转发表中没有找到的单播(未知单播)或者广播，或者组播*/
            br_flood_forward(br, skb, skb2, unicast);
    }
    /*设置了skb2表明是需要上送到自身的报文，如
    1）找到转发表项并且目的是local
    2)广播
    3)组播*/
    if (skb2)
        return br_pass_frame_up(skb2);

out:
    return 0;
drop:
    kfree_skb(skb);
    goto out;
}
EXPORT_SYMBOL_GPL(br_handle_frame_finish);




/*广播，组播，fdb表项中指明目的是自己的报文，重新走netif_receive_skb_sk,根据协议号上送三层处理*/
static int br_pass_frame_up(struct sk_buff *skb)
{
    struct net_device *indev, *brdev = BR_INPUT_SKB_CB(skb)->brdev;
    struct net_bridge *br = netdev_priv(brdev);
    struct pcpu_sw_netstats *brstats = this_cpu_ptr(br->stats);
    struct net_port_vlans *pv;

#if defined(CONFIG_BCM_KF_BLOG) && defined(CONFIG_BLOG)
    blog_lock();
    blog_link(IF_DEVICE, blog_ptr(skb), (void*)br->dev, DIR_RX, skb->len);
    blog_unlock();

    /* Gather general RX statistics */
    brdev->stats.rx_packets++;
    brdev->stats.rx_bytes += skb->len;
#endif

    u64_stats_update_begin(&brstats->syncp);
    brstats->rx_packets++;
    brstats->rx_bytes += skb->len;
    u64_stats_update_end(&brstats->syncp);

    /* Bridge is just like any other port.  Make sure the
     * packet is allowed except in promisc modue when someone
     * may be running packet capture.
     */
    pv = br_get_vlan_info(br);
    if (!(brdev->flags & IFF_PROMISC) &&
        !br_allowed_egress(br, pv, skb)) {
        kfree_skb(skb);
        return NET_RX_DROP;
    }

    indev = skb->dev;
    /*将skb->dev更新为brdev，即网桥设备，而不是实际物理口，这样子，重新走netif_receive_skb_sk时rx_handle就不会有值了*/
    skb->dev = brdev; 
    skb = br_handle_vlan(br, pv, skb);
    if (!skb)                            
        return NET_RX_DROP;
    /*修改接收设备后，重新走netif_receive_skb_sk流程*/
    return NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, NULL, skb,
               indev, NULL,
               netif_receive_skb_sk);
}


/*转发报文*/
/* called with rcu_read_lock */
void br_forward(const struct net_bridge_port *to, struct sk_buff *skb, struct sk_buff *skb0)
{
#if defined(CONFIG_BCM_KF_FBOND) && (defined(CONFIG_BCM_FBOND) || defined(CONFIG_BCM_FBOND_MODULE))
    to = br_fb_process(to, skb);
    if ( to ) {
#else
    if (should_deliver(to, skb)) {
#endif
        if (skb0)
            deliver_clone(to, skb, __br_forward);
        else
            __br_forward(to, skb);                                                                                                                                                      
        return;
    }

    if (!skb0)
        kfree_skb(skb);
}

/*被br_forward转发报文*/
static void __br_forward(const struct net_bridge_port *to, struct sk_buff *skb)
{
    struct net_device *indev;

    if (skb_warn_if_lro(skb)) {
        kfree_skb(skb);
        return;
    }

    skb = br_handle_vlan(to->br, nbp_get_vlan_info(to), skb);
    if (!skb)
        return;

    indev = skb->dev;
    skb->dev = to->dev;  /*修改skb->dev为转发表中的目的设备,实际的物理网口设备*/
    skb_forward_csum(skb);
    /*调用br_forward_finish发送报文*/
    NF_HOOK(NFPROTO_BRIDGE, NF_BR_FORWARD, NULL, skb,
        indev, skb->dev,
        br_forward_finish);
}

/*br_forward_finish调用br_dev_queue_push_xmit*/
int br_forward_finish(struct sock *sk, struct sk_buff *skb)
{
    return NF_HOOK(NFPROTO_BRIDGE, NF_BR_POST_ROUTING, sk, skb,
               NULL, skb->dev,
               br_dev_queue_push_xmit);                                                                                                                                               

}

/*br_dev_queue_push_xmit又调用dev_queue_xmit*/
int br_dev_queue_push_xmit(struct sock *sk, struct sk_buff *skb)
{   
    if (!is_skb_forwardable(skb->dev, skb)) {
        kfree_skb(skb);
    } else {
        skb_push(skb, ETH_HLEN);
        br_drop_fake_rtable(skb);
        skb_sender_cpu_clear(skb);
        dev_queue_xmit(skb);
    }

    return 0;
}
EXPORT_SYMBOL_GPL(br_dev_queue_push_xmit);




----------------------------------------------------------
广播
----------------------------------------------------------
/* called under bridge lock */
void br_flood_forward(struct net_bridge *br, struct sk_buff *skb,
              struct sk_buff *skb2, bool unicast)
{
    br_flood(br, skb, skb2, __br_forward, unicast);                                                                                                                                     
}    
/*__packet_hook就是br_flood_forward里面的__br_forward*/
/* called under bridge lock */                                                                                                                                                          
static void br_flood(struct net_bridge *br, struct sk_buff *skb,
             struct sk_buff *skb0,
             void (*__packet_hook)(const struct net_bridge_port *p,
                       struct sk_buff *skb),
             bool unicast)
{
    struct net_bridge_port *p;
    struct net_bridge_port *prev;

#if defined(CONFIG_BCM_KF_BLOG) && defined(CONFIG_BLOG)
    Blog_t * blog_p = blog_ptr(skb);

    if (blog_p && !blog_p->rx.multicast)
        blog_skip(skb);
#endif
    prev = NULL;
    /*循环网桥br下面的port_list链，调用__br_forward，在可以发送的端口上修改skb->dev,发送报文*/
    list_for_each_entry_rcu(p, &br->port_list, list) {
        /* Do not flood unicast traffic to ports that turn it off */
        if (unicast && !(p->flags & BR_FLOOD))
            continue;

        /* Do not flood to ports that enable proxy ARP */
        if (p->flags & BR_PROXYARP)
            continue;
        if ((p->flags & BR_PROXYARP_WIFI) &&
            BR_INPUT_SKB_CB(skb)->proxyarp_replied)
            continue;

        prev = maybe_deliver(prev, p, skb, __packet_hook);
        if (IS_ERR(prev))
            goto out;
    }

    if (!prev)
        goto out;

    if (skb0)
        deliver_clone(prev, skb, __packet_hook);
    else
        __packet_hook(prev, skb);
    return;

out:
    if (!skb0)
        kfree_skb(skb);
}

static struct net_bridge_port *maybe_deliver(
    struct net_bridge_port *prev, struct net_bridge_port *p,
    struct sk_buff *skb,
    void (*__packet_hook)(const struct net_bridge_port *p,
                  struct sk_buff *skb))
{
    int err;

#if defined(CONFIG_BCM_KF_FBOND) && (defined(CONFIG_BCM_FBOND) || defined(CONFIG_BCM_FBOND_MODULE))
    if (!should_deliver(p, skb, p->state))
#else
    if (!should_deliver(p, skb))
#endif
        return prev;

    if (!prev)
        goto out;

    err = deliver_clone(prev, skb, __packet_hook);
    if (err)
        return ERR_PTR(err);

out:
    return p;
}


static int deliver_clone(const struct net_bridge_port *prev,                                                                                                                          
             struct sk_buff *skb,
             void (*__packet_hook)(const struct net_bridge_port *p,
                           struct sk_buff *skb))
{   
    struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev;
#if defined(CONFIG_BCM_KF_BLOG) && defined(CONFIG_BLOG)
    struct sk_buff *skb2 = skb;
#endif
    skb = skb_clone(skb, GFP_ATOMIC);
    if (!skb) {
        dev->stats.tx_dropped++;
        return -ENOMEM;
    }

#if defined(CONFIG_BCM_KF_BLOG) && defined(CONFIG_BLOG)
    blog_clone(skb2, blog_ptr(skb));
#endif

    __packet_hook(prev, skb);
    return 0;
}
jackywgw
关注
专栏目录
linux网络协议栈br_handle_frame_finish
徐维溢的博客
04-08 3235
/* note: already called with rcu_read_lock */ int br_handle_frame_finish(struct net *net, struct sock *sk, struct sk_buff *skb) { const unsigned char *dest = eth_hdr(skb)->h_dest; struct net_bridge_port *p = br_port_get_rcu(skb->dev); struct net..
linux bridge 添加fdb,Linux协议栈--网桥设备的实现
weixin_29608475的博客
05-03 1789
网桥的概念网桥就是将桥一端的网络数据转发到桥的另一端的设备，这个转发是双向的。网桥和交换机是同一种设备。网桥工作在数据链路层上。网桥所连接的网络需要在同一网段内。网桥在Linux中的实现Linux中的网桥是一种虚拟设备。通常我们将一个或几个真实的设备(网卡)绑定到网桥设备上，网桥设备将绑定在它上面的设备视为端口port，从而统一管理所有从设备。可以为网桥配置一个IP地址，而它的MAC地址则是它管理...
桥数据包处理函数——br_handle_frame_finish（七）
草木相隔的博客
08-04 8337
上一节我们了解到，数据包如何走进桥，这一节我们简单看看，入口帧处理函数br_handle_frame_finish. 作用：br_handle_frame_finish函数主要是决策将不同类别的数据包做不同的分发路径。 其函数处理的过程如下图所示： 首先判断该数据包是否符合桥转发的条件：     (1)桥端口状态是否是开启状态，如果没有开启则丢掉数据包     (
Linux-4.20.8内核桥收包源码解析（六）----------决策函数br_handle_frame_finish
lw_yang的博客
02-25 2259
作者：Sophisticated
br_handle_frame()函数
inspiron_110的专栏
10-14 2747
/* * Called via br_handle_frame_hook. * Return 0 if *pskb should be processed furthur * 1 if *pskb is handled * note: already called with rcu_read_lock (preempt_disabled) */ int br_handle_frame(struct net_bridge_port *p, struct sk_buff **
linux网络协议栈br_handle_frame
徐维溢的博客
03-15 803
rx_handler_result_t br_handle_frame(struct sk_buff **pskb) { struct net_bridge_port *p; struct sk_buff *skb = *pskb; const unsigned char *dest = eth_hdr(skb)->h_dest; br_should_route_hook_t *rhook; //本地环回包直接返回 if (unlikely(skb->pkt_typ.
Linux-4.20.8内核桥收包源码解析（五）----------桥处理流程br_handle_frame
lw_yang的博客
02-25 2744
作者：Sophisticated
linux网桥处理函数学习-----br_handle_frame
jackywgw的专栏
10-20 2925
/* * Return NULL if skb is handled * note: already called with rcu_read_lock */ rx_handler_result_t br_handle_frame(struct sk_buff **pskb) { struct net_bridge_port *p; struct sk_buff *skb =
Linux网络协议栈4--bridge收发包
bigsheng2的博客
02-03 1248
bridge 是linux上的虚拟交换机，具有交换机的功能。 网卡收到包后，走到__netif_receive_skb_core后，剥完vlan找到vlan子接口（如果有的话），如果skb->dev是bridge成员口，就会走到bridge成员口的接收处理函数。 static int __netif_receive_skb_core(struct sk_buff *skb, bool pfmemalloc) { ...... /* bridge、ovs的接口，都会走到。 如果一个dev被添加到一
linux-网络协议栈1--从中断到上送协议栈
bigsheng2的博客
02-03 424
注： 内核代码是 4.9 版本 协议栈从报文接收说起，报文接收从网卡驱动说起。 两种方式，NAPI 和 非NAPI。 NAPI(New API) 是Linux内核针对网络数据传输做出的一个优化措施。 其目的是在大量数据传输时， 在收到硬件中断后，通过poll方式将传输过来的数据包统一处理， 通过禁止网络设备中断以减少硬件中断数量((Interrupt Mitigation)，从而实现更高的数据传输。 其中要点： 1、硬件中断后开始处理报文。中断处理函数只是触发软中断准备接收报文； 2、软中断中通过pool
Linux 网络协议栈开发（六）—— 二层桥转发蓝图（下）
知秋一叶
01-14 3640
上一节我们了解到，数据包如何走进桥，这一节我们简单看看，入口帧处理函数br_handle_frame_finish.   作用：br_handle_frame_finish函数主要是决策将不同类别的数据包做不同的分发路径。 其函数处理的过程如下图所示： 首先判断该数据包是否符合桥转发的条件： (1)桥端口状态是否是开启状态，如果没有开启则丢掉数据
桥数据包接收----br_handle_frame（六）
草木相隔的博客
07-27 5188
从这节开始，我们看看数据包如何在桥中进行转发的一些动作。 首先，上节的大蓝图中，标识除了，数据包是如何进入桥的，有一个很重要的函数br_handle_frame这个函数的初始注册地点是在桥添加接口的时候，注册在桥某一个接口上int br_add_if(struct net_bridge *br, struct net_device *dev) { ........ /*注册设备接收帧函
linux 网桥代码分析之网桥端口设备接收数据包处理分析Ⅴ
01-07 3255
1 网桥处理报文概述 网桥是一种2层网络互连设备，而不是一种网络协议。它在协议结构上并没有占有一席之地，因此不能通过向协议栈注册协议的方式来申请网桥数据包的处理。相反，网桥接口的数据包和一般接口（如eth0）在格式上完全是一样的，不同之处是网桥在2层上就对它进行了转了，而一般接口要在3层 才能根据路由信息来决定是否要转发，如何转发。 linux内核是通过一个虚拟的网桥设备来实现桥接的。这个虚拟设备可以绑定若干个以太网接口设备，从而将它们桥接起来。如下图（摘自ULNI）： 网桥设备br0绑定了eth0..
ovs vlan tag管理
zheng的博客
11-13 2734
1、背景 当使用ovs管理虚机的网络时，ovs会为虚机的tap设备添加一个内部的vlan tag，如下图所示，存在两个bridge，br0-ovs、br-int，其中br0-ovs挂载物理网卡设备eth2，br-int挂载虚机tatp设备，br0-ovs与br-int之间通过一对patch口连接，ovs为tap设备分配了内部vlan 2和内部vlan 3，本文主要描述ovs是如何完成这些内部vlan与外部vlan的转换。 2、流表规则 首先看一下br-int的流表规则，可以看到从int-br0-o
网卡VXLAN的offload技术介绍
mabin2005的专栏
04-08 2312
1.1 offload技术概述 首先要从术语offload说起，offload指的是将一个本来有软件实现的功能放到硬件上来实现，这样就可以将本来在操作系统上进行的一些数据包处理（如分片、重组等）放到网卡硬件上去做，降低系统CPU消耗的同时，提高处理性能。在neutron中，基于VXLAN的网络虚拟技术给服务器的CPU带来了额外的负担，比如封包、解包和校验等，VXLAN的封包和解包都是由OVS来完成的，使用VXLAN offload技术后，VXLAN的封包和解包都交给网卡或者硬件交换机来做了，那么网卡的VX
Linux Bridge
Neoooooooooo的专栏
03-11 1864
linux bridge遇到过的坑，MTU和multicast
TCP原理之：linux网桥
qq_17045267的博客
06-16 1617
TCP原理之：linux网桥 0. 前言 Linux内核提供了对网桥的支持，通过建立网桥设备能够将系统中的多个网络接口相连通，实现网络接口之前的通信。为了便于理解，我们可以将网桥想象成现实中的交换机，事实上网桥基本上实现了交换机的所有功能。 1. 原理解析 现实中的交换机我们可能比较清楚，而网桥这种抽象的、处于Linux系统内部的设备，它的机制和工作原理究竟是怎样的呢？简单来说，我们可以通过下面的一张示意图来进行解析： 与你平时对网桥的理解是不是有些不一样呢？对于内核以及协议栈而言，网桥也是一种网络接口，
linux 网络协议栈（链路层）
paoyingdapan的博客
11-07 1026
1.int netif_receive_skb(struct sk_buff *skb)，该函数是网络设备驱动到链路层协议栈的接口函数，该函数最后会调用__netif_receive_skb_core函数，下面主要介绍函数流程 1.1 list_for_each_entry_rcu(ptype, &amp;ptype_all, list) { //遍历ptype_all，如果有则做相应...
linux网桥--接受数据包
City_of_skey的博客
12-25 1933
 版权声明：如有需要，可供转载，但请注明出处：https://blog.csdn.net/City_of_skey/article/details/85254786 目录 1、netif_receive_skb 2、handle_bridge 3、br_handle_frame 4、br_handle_frame_finish 5、br_forward 6、br_flood_forw...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值