OVS bridge和port（三十三）

ovs-vsctl add-br br0 会在数据库里面加入新bridge的信息
ovs-vsctl add-port br0 eth0 会在数据库里面加入新的port信息

void bridge_run(void)
{
    //数据库发生变化
    if (ovsdb_idl_get_seqno(idl) != idl_seqno || vlan_splinters_changed) {
        idl_seqno = ovsdb_idl_get_seqno(idl);
            bridge_reconfigure(cfg ? cfg : &null_cfg);
    }
}

struct bridge {
    struct hmap_node node;      /* In 'all_bridges'. */
    char *name;                 /* User-specified arbitrary name. */
    char *type;                 /* Datapath type. */
    uint8_t ea[ETH_ADDR_LEN];   /* Bridge Ethernet Address. */
    uint8_t default_ea[ETH_ADDR_LEN]; /* Default MAC. */
    const struct ovsrec_bridge *cfg;

    /* OpenFlow switch processing. */
    struct ofproto *ofproto;    /* OpenFlow switch. */

    /* Bridge ports. */
    struct hmap ports;          /* "struct port"s indexed by name. */
    struct hmap ifaces;         /* "struct iface"s indexed by ofp_port. */
}

ofproto代表一个bridge的open flow proto

struct ofproto {
    struct hmap_node hmap_node; /* In global 'all_ofprotos' hmap. */
    /*all the operation fcuntion of the ofproto*/
    const struct ofproto_class *ofproto_class;
    char *type;                 /* Datapath type. */
    char *name;   
    uint64_t datapath_id;       /* Datapath ID. */
    struct oftable *tables;    /*flow tables*/
    int n_tables
    struct hmap ports;          /* Contains "struct ofport"s. */
    /* OpenFlow connections. */
    struct connmgr *connmgr;
}

struct ofproto_dpif {
    struct hmap_node all_ofproto_dpifs_node; /* In 'all_ofproto_dpifs'. */
    struct ofproto up;
    struct dpif_backer *backer;/*每个ofproto都有相同的dpif_backer, 它代表整个ovs datapath*/
}

struct dpif_backer {
    char *type;
    int refcount;
    struct dpif *dpif;
}

/*openvswitch datapath的handler, 负责与内核打交道*/
struct dpif {
    const struct dpif_class *dpif_class;
}

bridge_reconfigure(const struct ovsrec_open_vswitch *ovs_cfg)
{
    /*根据数据库更新信息添加或者删除bridge*/
    add_del_bridges(ovs_cfg);
    /*根据数据库更新信息为每个bridge收集新port或者删除port*/
    HMAP_FOR_EACH (br, node, &all_bridges) {
     /*如果是增加一个bridge,这里还会添加一个internal的local port为新的bridge*/
        bridge_collect_wanted_ports(br, splinter_vlans, &br->wanted_ports);
        bridge_del_ports(br, &br->wanted_ports);
    }

    HMAP_FOR_EACH_SAFE (br, next, node, &all_bridges) {
        if (!br->ofproto) {
            /*
            如果是新加的brdige会分配一个ofproto,实际分配oproto_dpif
            ofproto =  ofproto_dpif_class->alloc 
            ofproto->ofproto_class = ofproto_dpif_class
                 
            会获取dpif_backer,如果还没有就通过dp_if_create_and_open函数使用OVS_DP_CMD_NEW创建一个ovs-datapath,生成ovs-system设备
            从内核角度看，整个openvswitch系统就是一个datapath.
            ofproto->ofproto_class->construct(ofproto)
            */
 
            ofproto_create(br->name, br->type, &br->ofproto);
        }
    }

    HMAP_FOR_EACH (br, node, &all_bridges) {
        bridge_add_ports(br, &br->wanted_ports);
        shash_destroy(&br->wanted_ports);
    }
}

在内核看来用户态的bridge/datapath都只是整个openvswitch datapath的vport
只是新的bridge的vport是一个internal, add-port的是netdev, gre等

struct iface {
    struct list port_elem;      /* Element in struct port's "ifaces" list. */
    struct hmap_node ofp_port_node; /* In struct bridge's "ifaces" hmap. 
    struct port *port;          /* Containing port. */
    struct netdev *netdev;      /* Network device. */
    ofp_port_t ofp_port;        /* OpenFlow port number. */

    const struct ovsrec_interface *cfg; /*cfg for interface*/
};

struct port {
    struct bridge *bridge;
    char *name;
    struct hmap_node hmap_node; /* Element in struct bridge's "ports" hmap. */

    const struct ovsrec_port *cfg /*cfg for port*/
    /* An ordinary bridge port has 1 interface.
     * A bridge port for bonding has at least 2 interfaces. */
    struct list ifaces;         /* List of "struct iface"s. */
};

bridge_add_ports--->iface_create
{
    /*create interface*/
    iface_do_create(br, iface_cfg, port_cfg, &ofp_port, &netdev);
    iface->netdev = netdev;
    hmap_insert(&br->ifaces, &iface->ofp_port_node, hash_ofp_port(ofp_port));

    /*create port*/
    port = port_create(br, port_cfg)
    //hmap_insert(&br->ports, &port->hmap_node, hash_string(port->name, 0));
    list_push_back(&port->ifaces, &iface->port_elem);
}

struct netdev {
    /* The following do not change during the lifetime of a struct netdev. */
    char *name;                         /* Name of network device. */
    const struct netdev_class *netdev_class; 
}

struct netdev_linux {
    struct netdev up;
}

const struct netdev_class netdev_linux_class =
    NETDEV_LINUX_CLASS(
        "system",
        netdev_linux_construct,
        netdev_linux_get_stats,
        NULL,                    /* set_stats */
        netdev_linux_get_features,
        netdev_linux_get_status);

const struct netdev_class netdev_internal_class =
    NETDEV_LINUX_CLASS(
        "internal",
        netdev_linux_construct,
        netdev_internal_get_stats,
        netdev_internal_set_stats,
        NULL,                  /* get_features */
        netdev_internal_get_status);
}

/*gre*/
struct netdev_vport {
    struct netdev up;

    /* Tunnels. */
    struct netdev_tunnel_config tnl_cfg;
};
TUNNEL_CLASS("gre", "gre_system"),

int iface_do_create()
{
    /*根据type(internal, netdev, gre)获取interface 的netdev*/
    netdev_open(iface_cfg->name, iface_get_type(iface_cfg, br->cfg), &netdev);
    //netdev = rc->class->alloc()实际分配的是netdev_linux, gre是netdev_vport
    //rc->class->construct(netdev);对于netdev这种设备要存在, internal和gre是后面创建的

    /*设置interface options 只有gre设备才有*/
    error = iface_set_netdev_config(iface_cfg, netdev);

    ofproto_port_add(br->ofproto, netdev, ofp_portp);
    /*获取ofport, 并且将ofport与dp_port做映射 ofport_install-->port_construct分配ofport*/
    update_port(ofproto, netdev_name);
}

update_port
{
    ofport_open(ofproto, &ofproto_port, &pp);
    /*
        //allocate the ofport
        if (ofproto_port->ofp_port == OFPP_NONE) {
        if (!strcmp(ofproto->name, ofproto_port->name)) {
            ofproto_port->ofp_port = OFPP_LOCAL;
        } else {
            ofproto_port->ofp_port = alloc_ofp_port(ofproto,
                                                    ofproto_port->name);
        }
    }
    */
    ofport_install(ofproto, netdev, &pp);
}

struct ofport {
    struct hmap_node hmap_node; /* In struct ofproto's "ports" hmap. */
    struct ofproto *ofproto;    /* The ofproto that contains this port. */
    struct netdev *netdev;
    struct ofputil_phy_port pp;
    ofp_port_t ofp_port;        /* OpenFlow port number. */
};

struct ofport_dpif {
    struct hmap_node odp_port_node; /* In dpif_backer's "odp_to_ofport_map". */
    struct ofport up;
    /*datapath port*/
    odp_port_t odp_port;
}

ofport_install(struct ofproto *p, struct netdev *netdev, const struct ofputil_phy_port *pp)
{
    /*实际分配ofport_dpif*/
    ofport = p->ofproto_class->port_alloc();
    ofport->ofproto = p;
    ofport->netdev = netdev;
    ofport->pp = *pp;
    ofport->ofp_port = pp->port_no;
    ofport->created = time_msec();

    /* Add port to 'p'. */
    hmap_insert(&p->ports, &ofport->hmap_node, hash_ofp_port(ofport->ofp_port));
    /*map the ofport with dp_port*/
    error = p->ofproto_class->port_construct(ofport);
}

ofproto_port_add—>ofproto->ofproto_class->port_add

port_add
{
    /*netdev和internal都是获取的设备名, gre是获取的gre_system, 所以gre设备只会向add_port一次*/
    dp_port_name = netdev_vport_get_dpif_port(netdev, namebuf, sizeof namebuf);
    if (!dpif_port_exists(ofproto->backer->dpif, dp_port_name))
    {
        /*这里是port_no是openvswitch datapath的port no*/
        dpif_port_add(ofproto->backer->dpif, netdev, &port_no)
        //dpif->dpif_class->port_add(dpif, netdev, &port_no);
    }
}

dpif_linux_port_add(struct dpif *dpif_, struct netdev *netdev,
                    odp_port_t *port_nop)
{
    使用OVS_VPORT_CMD_NEW创建vport于内核中
}

///
内核态

int ovs_vport_cmd_new(struct sk_buff *skb, struct genl_info *info)
{
    parms.name = nla_data(a[OVS_VPORT_ATTR_NAME]);
    parms.type = nla_get_u32(a[OVS_VPORT_ATTR_TYPE]);
    parms.options = a[OVS_VPORT_ATTR_OPTIONS];
    parms.dp = dp;
    parms.port_no = port_no;
    parms.upcall_portid = nla_get_u32(a[OVS_VPORT_ATTR_UPCALL_PID]);

    vport = new_vport(&parms);--->ovs_vport_add(parms);--->vport_ops->create
}

//normal netdev: eth0 veth0 
const struct vport_ops ovs_netdev_vport_ops = {
    .type        = OVS_VPORT_TYPE_NETDEV,
    .create        = netdev_create,
    .destroy    = netdev_destroy,
    .get_name    = ovs_netdev_get_name,
    .send        = netdev_send,/*当报文的需要通过该vport发送的处理函数*/
};
struct vport *netdev_create(const struct vport_parms *parms)
{
     vport = ovs_vport_alloc(sizeof(struct netdev_vport), &ovs_netdev_vport_ops, parms);
    
     netdev_vport = netdev_vport_priv(vport);
     /*find the real dev*/
     netdev_vport->dev = dev_get_by_name(ovs_dp_get_net(vport->dp), parms->name);
     /*设置ovs内核处理函数, 使netdev收到的报文不再走传统协议栈*/
     netdev_rx_handler_register(netdev_vport->dev, netdev_frame_hook, vport)
}

static int netdev_send(struct vport *vport, struct sk_buff *skb)
{
    struct netdev_vport *netdev_vport = netdev_vport_priv(vport);
    int mtu = netdev_vport->dev->mtu;
    int len;
   
    skb->dev = netdev_vport->dev;
    len = skb->len;
    /*直接从该dev发送*/
    dev_queue_xmit(skb);
      
}

//internal: bridge port
const struct vport_ops ovs_internal_vport_ops = {
    .type        = OVS_VPORT_TYPE_INTERNAL,
    .create        = internal_dev_create,
    .destroy    = internal_dev_destroy,
    .get_name    = ovs_netdev_get_name,
    .send        = internal_dev_recv,
};

truct net_device_ops internal_dev_netdev_ops = {
    .ndo_start_xmit = internal_dev_xmit,
};

/*internal net device发送函数就是ovs的处理函数*/
static int internal_dev_xmit(struct sk_buff *skb, struct net_device *netdev)
{
    ovs_vport_receive(internal_dev_priv(netdev)->vport, skb, NULL);
}

struct vport *internal_dev_create(const struct vport_parms *parms)
{
    vport = ovs_vport_alloc(sizeof(struct netdev_vport), &ovs_internal_vport_ops, parms);
    netdev_vport = netdev_vport_priv(vport);

    /*创建一个ethernet device, netdev->netdev_ops = &internal_dev_netdev_ops;*/
    netdev_vport->dev = alloc_netdev(sizeof(struct internal_dev), parms->name, do_setup)
    internal_dev = internal_dev_priv(netdev_vport->dev);
    internal_dev->vport = vport;
    
    err = register_netdevice(netdev_vport->dev);
}
/*如果报文指定从internal设备发出, 数据包会重新注入协议栈*/
int internal_dev_recv(struct vport *vport, struct sk_buff *skb)
{
    skb->dev = netdev;
    skb->pkt_type = PACKET_HOST;
    skb->protocol = eth_type_trans(skb, netdev);
    skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);

    netif_rx(skb);
}

//gre port
const struct vport_ops ovs_gre_vport_ops = {
    .type        = OVS_VPORT_TYPE_GRE,
    .create        = gre_create,
    .destroy    = gre_tnl_destroy,
    .get_name    = gre_get_name,
    .send        = gre_send,
};

整个系统只创建一个gre device在内核

struct vport *gre_create(const struct vport_parms *parms)
{
    ovs_net = net_generic(net, ovs_net_id);
    if (ovsl_dereference(ovs_net->vport_net.gre_vport)) {
        vport = ERR_PTR(-EEXIST);
        goto error;
    }

    vport = ovs_vport_alloc(IFNAMSIZ, &ovs_gre_vport_ops, parms);
}

发送
报文通过gre口发送会根据下发具体action规则添加gre header以及deliver header
int gre_send(struct vport *vport, struct sk_buff *skb)

接收
当系统收到gre报文,去掉了deliver header获取gre header信息传递给gre_rcv，然后进入ovs处理函数进行处理

原文链接：https://www.cnblogs.com/pengkunfan/p/4079831.html