SDN功能实现（四） 实现自定义action（1）修改OVS源码<队列去重（内核态实现）>

实现功能：设计一个新的action，实现在冗余链路中的数据包去重

一：在内核级定义OVS  action

（一）在datapath/linux/compat/include/linux/openvswitch.h中添加：

enum ovs_action_attr {
    /* ... */

    /*
    * after #ifndef __KERNEL__ ... #endif.
    * the equals is thus ABSOLUTELY NECESSARY
    */

    OVS_ACTION_ATTR_RMDUPQUEUE = 23, /* struct ovs_action_rmdupqueue. */

    __OVS_ACTION_ATTR_MAX, /* Nothing past this will be accepted
                            * from userspace. */

    /* ... */

}

（二）注意：指定显示值

OVS_ACTION_ATTR_RMDUPQUEUE = 23 如果我们不为该枚举条目指定显式值，则内核和用户区部分 ovs-vswitchd将对新操作使用不同的代码（这里不加会出错）

（三）定义内核级别的OVS  action的消息结构体

/*
 * struct ovs_action_rmdupqueue - %OVS_ACTION_ATTR_RMDUPQUEUE action argument.
 * @queue_id: Algorithm used to choose queue number.
 * @max_len: basis used for setting queue[queue_id] size.
 */
struct ovs_action_rmdupqueue{
    uint32_t queue_id;
    uint32_t max_len;
};

二：在内核模块中实现自定义action的实现函数，用于调用执行

（一）队列业务实现，在datapath/flow_netlink.h中定义队列

int nsh_hdr_from_nlattr(const struct nlattr *attr, struct nshhdr *nh,
            size_t size);

//-------------------queue  start---------------------
#define MAX_QUEUE_SIZE 1000　　　　　　　　　　　　　　　　//最多可以为1000个流提供服务
#define MAX_QUEUE_LEN 1000                           //----改进：动态自适应算法，自动选择队列大小   或者 滑动窗口协议PRP 
typedef struct  
{
    int *queue;                                //队列指针（动态分配队列空间）
    int NUM;                                   //队列大小
    int TOP, REAR;                             //队首队尾标识
    int EmpFlag;                               //队列判空标识
}Queue;

void InitQueue(Queue* q, int n);            //初始化队列
int EmptyOrFullQueue(Queue q);            //队列判空以及判断满
int QueueLength(Queue q);                    //获取队列大小

int PushQueue(Queue* q,int ele);        //入队操作
int PopQueue(Queue* q);                        //出队操作

int RePushQueue(Queue* q, int ele);                                    //当一个数据第二次到达时对数据进行匹配出队操作
int FindElePos(Queue q, int ele,int* n);                                        //查找元素位置

void ShowData(Queue q);                        //显示队列数据

extern Queue Que[];
//-----------------queue end----------------------------
#endif /* flow_netlink.h */

（二）队列业务实现，在datapath/flow_netlink.c中实现队列

//-------------------queue  start---------------------
void InitQueue(Queue* q,int n)
{
    q->NUM = n;
    //空间回收
    if (q->queue != NULL)
    {
        kfree(q->queue);　　　　　　//改进：设置一个新的action（---del-flows指令，不是action） 实现队列的释放，清除上一个action
        q->queue = NULL;
    }

    if (q->NUM != 0)
    {
        q->queue = (int *)kmalloc(sizeof(int)*n,GFP_KERNEL);
        memset(q->queue, 0, sizeof(int)*n);
    }
    
    q->TOP = q->REAR = 0;
    q->EmpFlag = 1;                        //空队列
}

int EmptyOrFullQueue(Queue q)
{
    return q.EmpFlag;
}

int QueueLength(Queue q)
{
    if (EmptyOrFullQueue(q) == 1)
        return 0;
    if (EmptyOrFullQueue(q) == 2)
        return q.NUM;
    if (q.TOP > q.REAR)
        return q.REAR + q.NUM - q.TOP;
    else
        return q.REAR - q.TOP;
}

int PushQueue(Queue* q, int ele)
{
    if (q->NUM <= 0)
        return 0;                    //队列空间已经释放        设置常量

    if (RePushQueue(q, ele) == 1)    //重复插入，冗余数据---重点    改进：定义网络新协议，替换ip标识
        return 1;

    if (q->EmpFlag == 2)                        //队列满的情况入队
        PopQueue(q);                                //先出队队首，再入队

    q->queue[q->REAR] = ele;
    q->REAR = (q->REAR + 1) % q->NUM;
    if (q->TOP == q->REAR)
        q->EmpFlag = 2;                            //为满队列
    else
        q->EmpFlag = 3;

    return 0;
}


int PopQueue(Queue* q)
{
    if (q->NUM <= 0)
        return -2;                    //队列空间已经释放　　　　改进：可以队列动态空间划分

    int temp = q->queue[q->TOP];

    if (q->EmpFlag == 1)    //队列为空时，不允许出队
        return -1;

    q->TOP++;
    if (q->TOP == q->NUM)
        q->TOP = 0;
    if (q->TOP == q->REAR)
        q->EmpFlag = 1;                            //为空队列
    else
        q->EmpFlag = 3;
    return temp;
}

int RePushQueue(Queue* q, int ele)
{
    int n;                //用于记录元素个数
    int pos = FindElePos(*q, ele, &n);    
    if (pos == -1)
        return 0;        //可以直接插入

    q->TOP = pos;
    if (QueueLength(*q) == 0)
        q->EmpFlag = 1;
    else
        q->EmpFlag = 3;

    return 1;            //队列有重复
}

int FindElePos(Queue q, int ele,int* n)
{
    int i;
    for (i = 0; i < QueueLength(q); i++)
        if (q.queue[(i + q.TOP) % q.NUM] == ele)
        {
            *n = i + 1;                                                //返回队首到该元素，一共几个数据
            return (i + q.TOP + 1) % q.NUM;            //返回该元素位置的下一个位置，新的队首
        }
    return -1;        
}
//-----------------queue end----------------------------

队列操作：对于第二次到达的数据，若是在队列中匹配到，则将该数据以及前面的数据全部出队。

（三）在datapath/actions.c中的队列去重实现：

static bool rmdup_queue(struct sk_buff *skb, struct sw_flow_key *key,
             const struct nlattr *attr)
{
    /* since we can't use rand() in the kernel */
    struct ovs_action_rmdupqueue* rdque_act = nla_data(attr);
    uint32_t queue_id = rdque_act->queue_id - 1;    //can`t waste kernel space           改进：交换机返回设置后的队列号给控制器，用来进行记录调配https://www.cnblogs.com/ssyfj/p/11623514.html
    uint32_t max_len = rdque_act->max_len;
    struct iphdr *ip_header = (struct iphdr *)skb_network_header(skb);
    unsigned int ident = (unsigned int)ip_header->id;    //获取IP报文首部的id标识字段作为去重标准

    if(max_len == 0 && Que[queue_id].NUM == 0)    //don`t need to remove the redundancy packet
        return false;    //去重复，后面进行删除---false不进行去重复
    else if (max_len == 0 && Que[queue_id].NUM != 0){ //init queue infomation
        InitQueue(&Que[queue_id],max_len);
        return false;   //去重复，后面进行删除---false不进行去重复
    } 
    else if (max_len != 0 && max_len != Que[queue_id].NUM){    //reinit the queue
        InitQueue(&Que[queue_id],max_len);
        return PushQueue(&Que[queue_id],ident);    //PushQueue返回1,表示有重复，返回0,表示没有重复
    }
    else{    //judge the packet, decide to remove this packet
        return PushQueue(&Que[queue_id],ident);    //PushQueue返回1,表示有重复，返回0,表示没有重复
    }
}

（四）do_execute_actions方法实现对OVS action中OVS_ACTION_ATTR_RMDUPQUEUE去重业务的调用

/* Execute a list of actions against 'skb'. */
static int do_execute_actions(struct datapath *dp, struct sk_buff *skb,
                  struct sw_flow_key *key,
                  const struct nlattr *attr, int len)
{
    const struct nlattr *a;
    int rem;

    for (a = attr, rem = len; rem > 0;
         a = nla_next(a, &rem)) {
        int err = 0;

        switch (nla_type(a)) {
        case OVS_ACTION_ATTR_OUTPUT: 
            ....
　　　　　　  break;
        case OVS_ACTION_ATTR_RMDUPQUEUE:
            if(rmdup_queue(skb, key, a))    //当我们的队列发现存在重复，则进行去重操作（删除当前数据包）
            {
                while (rem) {
                    a = nla_next(a, &rem);
                }
            }
            break;
        case OVS_ACTION_ATTR_PUSH_MPLS:
            err = push_mpls(skb, key, nla_data(a));
            break;    

三：在用户态下定义OVS action

（一）所有action定义在include/openvswitch/ofp-actions.h中添加

    OFPACT(GOTO_TABLE,      ofpact_goto_table,  ofpact, "goto_table")   \
    OFPACT(RMDUPQUEUE,      ofpact_rmdupqueue,  ofpact, "rmdupqueue") 

（二）实现OVS  action的消息体

/* OFPACT_RMDUPQUEUE.
 *
 * Used for OFPAT_RMDUPQUEUE */
struct ofpact_rmdupqueue {
    OFPACT_PADDED_MEMBERS(
        struct ofpact ofpact;
        uint32_t queue_id;
        uint32_t max_len;           /* Uint probability, "covers" 0->1 range. */
    );
    uint8_t data[];
};

四：用户态下的OVS action实现（与内核态定义的OVS action有关，引入了内核定义的头文件，联系内核态和用户态两者的OVS action），这里我们使用OVS_NOT_REACHED,不实现用户态的action

（一）lib/odp-execute.c:用户态调用，执行action

void
odp_execute_actions(void *dp, struct dp_packet_batch *batch, bool steal,
                    const struct nlattr *actions, size_t actions_len,
                    odp_execute_cb dp_execute_action)
{
    struct dp_packet *packet;
    ......
    
    switch ((enum ovs_action_attr) type) {


        case OVS_ACTION_ATTR_UNSPEC:
        case OVS_ACTION_ATTR_RMDUPQUEUE:
        case __OVS_ACTION_ATTR_MAX:
            OVS_NOT_REACHED();
        }
    }

    dp_packet_delete_batch(batch, steal);
}

（二）lib/dpif.c:

static void
dpif_execute_helper_cb( /* ... */ )
{
    /* ... */
    switch ((enum ovs_action_attr)type) {
    /* ... */
    case OVS_ACTION_ATTR_RMDUPQUEUE:
        OVS_NOT_REACHED();
    }
}

（三）ofproto/ofproto-dpif-ipfix.c:

void
dpif_ipfix_read_actions( /* ... */ )
{
    /* ... */
    switch (type) {
    /* ... */
    case OVS_ACTION_ATTR_RMDUPQUEUE:
        /* Again, ignore for now. Not needed. */
        break;
    }
}

（四）ofproto/ofproto-dpif-sflow.c:

void
dpif_sflow_read_actions( /* ... */ )
{
    switch (type) {
    /* ... */
    case OVS_ACTION_ATTR_RMDUPQUEUE:
        /* Ignore sFlow for now, unless needed. */
        break;
    }
}

五：多功能聚合lib/odp-util.c（这里的格式化、解析都是针对内核态实现）

（一）实现格式化操作，获取了内核OVS action消息体中的内容，格式化为字符串形式

static void
format_odp_rmdupqueue_action(struct ds *ds, const struct ovs_action_rmdupqueue *rdq_act)
{
    ds_put_format(ds, "rmdupqueue(queue_id=%"PRIu32",max_len=%"PRIu32")",rdq_act->queue_id,rdq_act->max_len);
}

static void
format_odp_action(struct ds *ds, const struct nlattr *a,
                  const struct hmap *portno_names)
{
    int expected_len;
    enum ovs_action_attr type = nl_attr_type(a);

    switch (type) {
    case OVS_ACTION_ATTR_METER:
        ds_put_format(ds, "meter(%"PRIu32")", nl_attr_get_u32(a));
        break;
    ......
    case OVS_ACTION_ATTR_RMDUPQUEUE: 
        format_odp_rmdupqueue_action(ds, nl_attr_get(a));
        break;     
    case OVS_ACTION_ATTR_UNSPEC:
    case __OVS_ACTION_ATTR_MAX:
    default:
        format_generic_odp_action(ds, a);
        break;
    }
}

（二）实现解析化操作，根据我们的字符串，进行解析，从而将从字符串中获取的信息放入内核OVS action消息体中

static int
parse_odp_action(const char *s, const struct simap *port_names,
                 struct ofpbuf *actions)
{
    {
        uint32_t port;
        int n;

        if (ovs_scan(s, "%"SCNi32"%n", &port, &n)) {
            nl_msg_put_u32(actions, OVS_ACTION_ATTR_OUTPUT, port);
            return n;
        }
    }

    ......

    {
        uint32_t queue_id,max_len;
        struct ovs_action_rmdupqueue rdque;
        int n;

        if (ovs_scan(s, "rmdupqueue(queue_id=%"SCNi32",max_len=%"SCNi32")%n", &queue_id, &max_len, &n)) {
            rdque.queue_id = queue_id;
            rdque.max_len = max_len;
            nl_msg_put_unspec(actions, OVS_ACTION_ATTR_RMDUPQUEUE,
                  &rdque, sizeof rdque);
            return n;
        }
    }

    {
        if (!strncmp(s, "clone(", 6)) {
　　　　　　.....
　　.....

（三）设置action长度

static int
odp_action_len(uint16_t type)
{
    if (type > OVS_ACTION_ATTR_MAX) {
        return -1;
    }

    switch ((enum ovs_action_attr) type) {
    case OVS_ACTION_ATTR_OUTPUT: return sizeof(uint32_t);
    ......
    case OVS_ACTION_ATTR_RMDUPQUEUE: return sizeof(struct ovs_action_rmdupqueue);

    case OVS_ACTION_ATTR_UNSPEC:
    case __OVS_ACTION_ATTR_MAX:
        return ATTR_LEN_INVALID;
    }

    return ATTR_LEN_INVALID;
}

六：定义一个OpenFlow action

（一）lib / ofp-actions.c：引入添加自己的操作代码，作为OpenFlow的扩展

enum ofp_raw_action_type {
    /* ... */

    /* NX1.3+(47): struct nx_action_decap, ... */
    NXAST_RAW_DECAP,


    /* OF1.0+(30): struct ofp10_action_rmdupqueue. */
    OFPAT_RAW_RMDUPQUEUE,

/* ... */
}

（二）注释说明以及自动生成函数的补充

注释非常重要，说明了协议版本，序号，构造openflow消息所需参数
有些函数头是根据协议版本、您选择的代码和操作所需的参数类型自动生成的。 后面的序号是独一无二的，不能在同一协议版本中出现两个一样的序号

put_OFPAT_action构造openflow消息
put_OFPAT_RMDUPQUEUE: 根据 下面的消息结构体构造出openflow消息

（三）定义对应的OpenFlow action的消息结构体

struct ofp10_action_rmdupqueue {
    ovs_be16 type;              /* OFPAT_VENDOR. */
    ovs_be16 len;               /* At least 16. */
    ovs_be32 vendor;            /* NX_VENDOR_ID. */
    ovs_be16 subtype;           /* NXAST_OUTPUT_TRUNC. */
    uint8_t zeros[6];
    ovs_be32 queue_id;
    ovs_be32 max_len;
};
OFP_ASSERT(sizeof(struct ofp10_action_rmdupqueue) == 24);  //必须是8字节的整数倍

七：OpenFlow Action与OpenVSwitch action的转化（编码、解码、格式化....)

（一）补充各个函数的说明

（1）ofpact_decode---->decode_OFPAT_RAW_RMDUPQUEUE: 解openflow消息生成openvswitch action
（2）ofpact_encode---->encode_RMDUPQUEUE: 从ofpact_type构造openflow消息
（3）ofpact_parse---->parse_RMDUPQUEUE: 从字符串解析构造openvswitch action
（4）ofpact_format---->format_RMDUPQUEUE: 将openvswitch action转化为string
（5）ofpact_check---->check_RMDUPQUEUE:校验openvswitch action

注意：

在我们添加流表项时，会先执行解析、检查、编码操作（从字符串解析OVS action，然后构造openflow消息）

在我们使用ovs-ofctl dump-flows 交换机，会先执行解码、格式化操作（将openflow消息转换为OVS action，然后根据OVS action中的参数去格式化为字符串显示）

（二）在lib/ofp-actions.c中修改代码:定义新的动作，编码，解码，形式化和校验。

/*use queue to achive remove packet duplicate*/
struct ofp10_action_rmdupqueue {
    ovs_be16 type;              /* OFPAT_VENDOR. */
    ovs_be16 len;               /* At least 16. */
    ovs_be32 vendor;            /* NX_VENDOR_ID. */
    ovs_be16 subtype;           /* NXAST_OUTPUT_TRUNC. */
    uint8_t zeros[6];
    ovs_be32 queue_id;
    ovs_be32 max_len;
};
OFP_ASSERT(sizeof(struct ofp10_action_rmdupqueue) == 24);  //定义的消息体下实现编码、解码等即可

/* Encoding the action packet to put on the wire. */
static void
encode_RMDUPQUEUE(const struct ofpact_rmdupqueue *rdque,
                    enum ofp_version ofp_version OVS_UNUSED,
                    struct ofpbuf *out)
{
    struct ofp10_action_rmdupqueue* of_rdque = put_OFPAT_RMDUPQUEUE(out);
    of_rdque->queue_id = rdque->queue_id;
    of_rdque->max_len = rdque->max_len;
}

/* Reversing the process. */
static enum ofperr
decode_OFPAT_RAW_RMDUPQUEUE(const struct ofp10_action_rmdupqueue* of_rdque,
                            enum ofp_version ofp_version OVS_UNUSED,
                            struct ofpbuf *out)
{
    struct ofpact_rmdupqueue *rdque;
    rdque = ofpact_put_RMDUPQUEUE(out);
    rdque->queue_id = of_rdque->queue_id;
    rdque->max_len = of_rdque->max_len;

    return 0;
}

/* Helper for below. */
static char * OVS_WARN_UNUSED_RESULT
parse_rdque(char *arg, struct ofpbuf *ofpacts)
{
    struct ofpact_rmdupqueue *rdque;
    char *key, *value;
    rdque = ofpact_put_RMDUPQUEUE(ofpacts);

    while (ofputil_parse_key_value(&arg, &key, &value)) {
        char *error = NULL;

        if (!strcmp(key, "queue_id")) {
            error = str_to_u32(value, &rdque->queue_id);
        } else if (!strcmp(key, "max_len")) {
            error = str_to_u32(value, &rdque->max_len);
        }
     
        if (error) return error;
    }

    return NULL;
}

/* Go from string-formatted args into an action struct.
e.g. ovs-ofctl add-flow ... actions=rmdupqueue(queue_id=3,max_len=100),output:"s2-eth0"
*/
static char * OVS_WARN_UNUSED_RESULT
parse_RMDUPQUEUE(char *arg, const struct ofpact_parse_params *pp)
{
    return parse_rdque(arg, pp->ofpacts);
}

/* Used when printing info to console. */
static void
format_RMDUPQUEUE(const struct ofpact_rmdupqueue *rdque,
                const struct ofpact_format_params *fp)
{
    /* Feel free to use e.g. colors.param,
    colors.end around parameter names */
    ds_put_format(fp->s, "rmdupqueue(queue_id=%"PRIu32, rdque->queue_id);
    ds_put_format(fp->s, ",max_len=%"PRIu32")", rdque->max_len);
}

/* ... */

static enum ofperr
check_RMDUPQUEUE(const struct ofpact_rmdupqueue *rdque OVS_UNUSED,
                const struct ofpact_check_params *cp OVS_UNUSED)
{
    /* My method needs no checking. Probably. */
    return 0;
}

（三）lib/ofp-actions.c:

struct ofpact *
ofpact_next_flattened(const struct ofpact *ofpact)
{
    switch (ofpact->type) {
        /* ... */
        case OFPACT_RMDUPQUEUE:
            return ofpact_next(ofpact);
    }
    /* ... */
}

/* ... */

enum ovs_instruction_type
ovs_instruction_type_from_ofpact_type(enum ofpact_type type)
{
    switch (type) {
    /* ... */
    case OFPACT_RMDUPQUEUE:
    default:
        return OVSINST_OFPIT11_APPLY_ACTIONS;
    /* ... */
    }
}

/* ... */

static bool
ofpact_outputs_to_port(const struct ofpact *ofpact, ofp_port_t port)
{
    switch (ofpact->type) {
    /* ... */
    case OFPACT_RMDUPQUEUE:
    default:
        return false;
    }
}

static enum action_set_class
action_set_classify(const struct ofpact a*)
{
    switch (a->type) {
    /* ... */


    /* NEVER */
    /* ... */
    case OFPACT_RMDUPQUEUE:
        return ACTION_SLOT_INVALID;

    /* ... */
    }
}

八：处理内核数据路径和用户级守护程序之间的通信

在某些情况下，守护程序和内核模块通过Netlink套接字相互通信。

守护程序在到达时将流操作向下发送到内核（用于数据包处理），并在到达时轮询来自内核的任何上行调用。

通常，当到达的数据包与任何已知条目都不匹配时（即必须将该数据包发送到控制器，或者需要具体实例化通配符规则），就会发生这种情况。

（一）实现通信ofproto/ofproto-dpif-xlate.c:

/* Put this with the other "compose" functions. */
static void
compose_rmdupqueue_action(struct xlate_ctx *ctx, struct ofpact_rmdupqueue *op)　　//可以看出是将用户态的消息体传入内核态中了
{
    struct {    
        ovs_be32 queue_id;
        ovs_be32 max_len;
    } odp_pd_label;

    odp_pd_label.queue_id = op->queue_id;
    odp_pd_label.max_len = op->max_len;
    nl_msg_put_unspec(ctx->odp_actions, OVS_ACTION_ATTR_RMDUPQUEUE,
                      &odp_pd_label, sizeof odp_pd_label);
}

static void
do_xlate_actions(const struct ofpact *ofpacts, size_t ofpacts_len,
                 struct xlate_ctx *ctx, bool is_last_action,
                 bool group_bucket_action)
{
    struct flow_wildcards *wc = ctx->wc;
    ......
    switch (a->type) {
         ......
        case OFPACT_RMDUPQUEUE:
            compose_rmdupqueue_action(ctx, ofpact_get_RMDUPQUEUE(a));
            break;

        case OFPACT_CLONE:
        ......
    }
}

/* No action can undo the packet drop: reflect this. */
static bool
reversible_actions(const struct ofpact *ofpacts, size_t ofpacts_len)
{
    const struct ofpact *a;

    OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
        switch (a->type) {
        /*... */
        case OFPACT_RMDUPQUEUE:
            return false;
        }
    }
    return true;
}

/* ... */

/* RMDUPQUEUE likely doesn't require explicit thawing. */
static void
freeze_unroll_actions( /* ... */ )
{
    /* ... */
    switch (a->type) {
        case OFPACT_RMDUPQUEUE:
            /* These may not generate PACKET INs. */
            break;
    }
}

/* ... */

/* Naturally, don't need to recirculate since we don't change packets. */
static void
recirc_for_mpls(const struct ofpact *a, struct xlate_ctx *ctx)
{
    /* ... */

    switch (a->type) {
    case OFPACT_RMDUPQUEUE:
    default:
        break;
    }
}

九：datapath/flow_netlink.c:内核部分，是对参数长度和值的最后检查

static int __ovs_nla_copy_actions( /*...*/ )
{
    /* ... */
    static const u32 action_lens[OVS_ACTION_ATTR_MAX + 1] = {
        /* ... */
        [OVS_ACTION_ATTR_RMDUPQUEUE] = sizeof(struct ovs_action_rmdupqueue),
    };
    /* ... */

    /* Be careful here, your compiler may not catch this one
    * even with -Werror */
    switch (type) {
    /* ... */
    case OVS_ACTION_ATTR_RMDUPQUEUE:
        /* Finalest sanity checks in the kernel. */
        break;
    /* ... */
    }
    /* ... */
}