| /* |
| * Copyright (c) 2014, 2016, The Linux Foundation. All rights reserved. |
| * Permission to use, copy, modify, and/or distribute this software for |
| * any purpose with or without fee is hereby granted, provided that the |
| * above copyright notice and this permission notice appear in all copies. |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
| * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
| * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT |
| * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| */ |
| |
| |
| |
| #include "fal_nat.h" |
| #include "fal_ip.h" |
| #include "hsl_api.h" |
| #include "sw.h" |
| #include "hsl.h" |
| #include "hsl_dev.h" |
| #include "hsl_port_prop.h" |
| #include "dess_igmp.h" |
| #include "dess_reg.h" |
| #include "dess_acl.h" |
| #include "fal_multi.h" |
| #include "sal/os/aos_lock.h" |
| |
| #if 0 |
| /** |
| * I/F prototype for complete igmpv3 & mldv2 support |
| */ |
| |
| /*supports 32 entries*/ |
| #define FAL_IGMP_SG_ENTRY_MAX 32 |
| |
| typedef enum |
| { |
| FAL_ADDR_IPV4 = 0, |
| FAL_ADDR_IPV6 |
| } fal_addr_type_t; |
| |
| typedef struct |
| { |
| fal_addr_type_t type; |
| union |
| { |
| fal_ip4_addr_t ip4_addr; |
| fal_ip6_addr_t ip6_addr; |
| } u; |
| } fal_igmp_sg_addr_t; |
| |
| typedef struct |
| { |
| fal_igmp_sg_addr_t source; |
| fal_igmp_sg_addr_t group; |
| fal_pbmp_t port_map; |
| } fal_igmp_sg_entry_t; |
| |
| /** |
| * @brief set PortMap of IGMP sg entry. |
| * search entry according to source/group address, |
| * update PortMap if SG entry is found, otherwise create a new sg entry. |
| * @param[in] dev_id device id |
| * @param[in-out] entry SG entry |
| * @return SW_OK or error code |
| */ |
| HSL_LOCAL sw_error_t |
| dess_igmp_sg_entry_set(a_uint32_t dev_id, fal_igmp_sg_entry_t * entry); |
| |
| /** |
| * @brief clear PortMap of IGMP sg entry. |
| * search entry according to source/group address, |
| * update PortMap if SG entry is found, delete the entry in case PortMap was 0. |
| * SW_NOT_FOUND will be returned in case search failed. |
| * @param[in] dev_id device id |
| * @param[in-out] entry SG entry |
| * @return SW_OK or error code |
| */ |
| HSL_LOCAL sw_error_t |
| dess_igmp_sg_entry_clear(a_uint32_t dev_id, fal_igmp_sg_entry_t * entry); |
| |
| #define MULTI_DEBUG_ |
| #ifdef MULTI_DEBUG_ |
| #define MULTI_DEBUG(x...) aos_printk(x) |
| #else |
| #define MULTI_DEBUG(x...) |
| #endif |
| |
| #define FAL_ACL_LIST_MULTICAST 55 |
| #define FAL_MULTICAST_PRI 5 |
| |
| #define MULT_ACTION_SET 1 |
| #define MULT_ACTION_CLEAR 1 |
| |
| static a_uint32_t rule_nr=1; |
| |
| typedef struct |
| { |
| a_uint8_t index; //MAX is 32 |
| fal_igmp_sg_entry_t entry; //Stores the specific ACL rule info |
| } multi_acl_info_t; |
| #endif |
| |
| static a_uint32_t mul_rule_nr=1; |
| |
| void |
| dess_multicast_init(a_uint32_t dev_id); |
| |
| HSL_LOCAL sw_error_t multi_portmap_aclreg_set(a_uint32_t pos, fal_igmp_sg_entry_t * entry); |
| |
| static multi_acl_info_t multi_acl_info[FAL_IGMP_SG_ENTRY_MAX]; |
| static multi_acl_info_t multi_acl_group[FAL_IGMP_SG_ENTRY_MAX]; |
| |
| static int ip6_addr_is_null(fal_ip6_addr_t *ip6) |
| { |
| if (NULL == ip6) |
| { |
| aos_printk("Invalid ip6 address\n"); |
| return -1; |
| } |
| if(0 == ip6->ul[0] && 0 == ip6->ul[1] && 0 == ip6->ul[2] && 0 == ip6->ul[3]) |
| return 1; |
| else |
| return 0; |
| } |
| static int multi_source_is_null(fal_igmp_sg_addr_t *s) |
| { |
| if (NULL == s) |
| { |
| aos_printk("Invalid source address\n"); |
| return -1; |
| } |
| if(0 == s->type && 0==s->u.ip4_addr) |
| return 1; |
| if(1 == s->type && 1 == ip6_addr_is_null(&(s->u.ip6_addr))) |
| return 1; |
| |
| return 0; |
| } |
| |
| HSL_LOCAL int iterate_multicast_acl_rule(int list_id, int start_n) |
| { |
| a_uint32_t dev_id=0; |
| a_uint32_t rule_id; |
| sw_error_t ret; |
| fal_acl_rule_t rule= {0}; |
| |
| if(start_n>=FAL_IGMP_SG_ENTRY_MAX || start_n < 0) |
| { |
| return -1; |
| } |
| |
| for(rule_id=0; rule_id<FAL_IGMP_SG_ENTRY_MAX; rule_id++) |
| { |
| ret = dess_acl_rule_query(dev_id, list_id, rule_id, &rule); |
| |
| if (ret==SW_NOT_FOUND ) |
| break;//NOT found in ACL rule |
| if((rule_id+start_n)>=FAL_IGMP_SG_ENTRY_MAX) |
| { |
| return -1; |
| } |
| |
| multi_acl_info[rule_id+start_n].index = rule_id; // consider here... index is NOT related start_n |
| //MULTI_DEBUG("normal query1: rule dest_ip4_val=%x, src ip4=%x, dst_ip6=%x, ports=%x\n", |
| //rule.dest_ip4_val, rule.src_ip4_val, rule.dest_ip6_val.ul[0], rule.ports); |
| |
| if(rule.dest_ip4_val !=0 && ip6_addr_is_null(&rule.dest_ip6_val)) //only ip4 |
| { |
| multi_acl_info[rule_id+start_n].entry.group.type = FAL_ADDR_IPV4; |
| multi_acl_info[rule_id+start_n].entry.source.type = FAL_ADDR_IPV4; |
| multi_acl_info[rule_id+start_n].entry.group.u.ip4_addr = rule.dest_ip4_val; |
| multi_acl_info[rule_id+start_n].entry.source.u.ip4_addr = rule.src_ip4_val; |
| multi_acl_info[rule_id+start_n].entry.port_map= rule.ports; |
| } |
| else if(rule.dest_ip4_val ==0 && !ip6_addr_is_null(&rule.dest_ip6_val)) //only ip6 |
| { |
| multi_acl_info[rule_id+start_n].entry.group.type = FAL_ADDR_IPV6; |
| multi_acl_info[rule_id+start_n].entry.source.type = FAL_ADDR_IPV6; |
| memcpy(&(multi_acl_info[rule_id+start_n].entry.group.u.ip6_addr), &(rule.dest_ip6_val), sizeof(rule.dest_ip6_val)); |
| memcpy(&(multi_acl_info[rule_id+start_n].entry.source.u.ip6_addr), &(rule.src_ip6_val), sizeof(rule.src_ip6_val)); |
| multi_acl_info[rule_id+start_n].entry.port_map= rule.ports; |
| } |
| if (FAL_FIELD_FLG_TST(rule.field_flg, FAL_ACL_FIELD_MAC_VID)) |
| { |
| multi_acl_info[rule_id+start_n].entry.vlan_id = rule.vid_val; |
| } |
| else |
| { |
| multi_acl_info[rule_id+start_n].entry.vlan_id = 0xffff; |
| } |
| } |
| |
| return rule_id+start_n; |
| } |
| /* |
| ** Iterate the total 32 multicast ACL entries. |
| After the function completes: |
| 1. Stores all multicast related ACL rules in multi_acl_info[32] |
| 2. return the number of multicast related ACL rules |
| */ |
| HSL_LOCAL a_uint32_t dess_multicast_acl_query(void) |
| { |
| int start_n; |
| int total_n; |
| //a_uint32_t i; |
| |
| start_n = iterate_multicast_acl_rule(FAL_ACL_LIST_MULTICAST, 0); |
| if(-1 == start_n) |
| aos_printk("ACL rule1 is FULL\n"); |
| total_n = iterate_multicast_acl_rule(FAL_ACL_LIST_MULTICAST+1, start_n); |
| if(-1 == total_n) |
| aos_printk("ACL rule2 is FULL\n"); |
| |
| MULTI_DEBUG("KKK, the total ACL rule number is %d, (G,S) number=%d\n", total_n, start_n); |
| /* |
| for(i=0;i<total_n;i++) |
| MULTI_DEBUG("KKK, indx=%d, multi_acl_info[%d].entry=[%d][%x]\n", multi_acl_info[i].index,i, |
| multi_acl_info[i].entry.group.type, multi_acl_info[i].entry.group.u.ip4_addr ); |
| */ |
| |
| return total_n; |
| } |
| |
| HSL_LOCAL a_uint32_t dess_multicast_acl_total_n(a_uint32_t list_id) |
| { |
| a_uint32_t dev_id=0; |
| a_uint32_t ret; |
| a_uint32_t rule_id; |
| fal_acl_rule_t rule= {0}; |
| |
| for(rule_id=0; rule_id<FAL_IGMP_SG_ENTRY_MAX; rule_id++) |
| { |
| ret = dess_acl_rule_query(dev_id, list_id, |
| rule_id, &rule); |
| if(ret==SW_NOT_FOUND) |
| return rule_id; |
| |
| } |
| return 0; |
| } |
| |
| #define DESS_FILTER_ACT_ADDR 0x5a000 |
| #define DESS_FILTER_MSK_ADDR 0x59000 |
| HSL_LOCAL sw_error_t multi_portmap_aclreg_set_all(a_uint32_t pos, fal_igmp_sg_entry_t * entry) |
| { |
| a_uint32_t i, base, addr; |
| a_uint32_t dev_id=0; |
| a_uint32_t msk_valid=0; |
| sw_error_t rv = SW_OK; |
| |
| /* 2'b00:start; 2'b01:continue; 2'b10:end; 2'b11:start&end*/ |
| for(i=pos; i<pos+4; i++) |
| { |
| base = DESS_FILTER_MSK_ADDR +(i<<5); |
| addr = base+(4<<2); //fifth byte |
| HSL_REG_ENTRY_GEN_GET(rv, dev_id, addr, sizeof (a_uint32_t), |
| (a_uint8_t *) (&msk_valid), |
| sizeof (a_uint32_t)); |
| |
| SW_RTN_ON_ERROR(rv); |
| if ((((msk_valid>>6)&0x3) == 0x3) || (((msk_valid>>6)&0x3) == 0x2)) |
| { |
| rv = multi_portmap_aclreg_set(i, entry); |
| break; |
| } |
| else if ((((msk_valid>>6)&0x3)) == 0x0 || (((msk_valid>>6)&0x3) == 0x1)) |
| { |
| rv = multi_portmap_aclreg_set(i, entry); |
| continue; |
| } |
| else |
| { |
| aos_printk("The rule valid bit:6 7 is wrong!!!"); |
| break; |
| } |
| } |
| return rv; |
| } |
| HSL_LOCAL sw_error_t multi_portmap_aclreg_set(a_uint32_t pos, fal_igmp_sg_entry_t * entry) |
| { |
| a_uint32_t i, base, addr; |
| a_uint32_t dev_id=0; |
| sw_error_t rv; |
| a_uint32_t act[3]= {0}; |
| fal_pbmp_t pm; |
| |
| pm = entry->port_map; |
| |
| base = DESS_FILTER_ACT_ADDR + (pos << 4); |
| for (i = 0; i < 3; i++) |
| { |
| addr = base + (i << 2); |
| HSL_REG_ENTRY_GEN_GET(rv, dev_id, addr, sizeof (a_uint32_t), |
| (a_uint8_t *) (&act[i]), |
| sizeof (a_uint32_t)); |
| //MULTI_DEBUG("2:Get register value 0x%x =%x\n", addr, act[i]); |
| SW_RTN_ON_ERROR(rv); |
| } |
| |
| act[1] &= ~(0x7<<29); // clear the high 3 bits |
| act[1] |= (pm&0x7)<<29; //the low 3 bits of pm means redirect port 0,1,2 |
| |
| /* New modification: update acl ACTION register from DENY to redirect */ |
| if (((act[2]>>6)&0x7) == 0x7) //DENY mode |
| { |
| if(pm) |
| { |
| act[2] &= ~(0x7<<6);//clear DENY bits |
| act[2] |= (0x1<<4); //DES_PORT_EN set 1, enable |
| } |
| } |
| else if (((act[2]>>4)&0x1) == 0x1) //redirect mode |
| { |
| if(pm==0) |
| { |
| act[2] &= ~(0x1<<4);//clear redirect bits |
| act[2] |= (0x7<<6); //set to DENY |
| } |
| } |
| |
| act[2] &= ~0xf; //clear the low 4 bits of port 3,4,5,6 |
| act[2] |= (pm>>3)&0xf; |
| |
| addr = base + (1<<2); |
| HSL_REG_ENTRY_GEN_SET(rv, dev_id, addr, sizeof (a_uint32_t), |
| (a_uint8_t *) (&act[1]), sizeof (a_uint32_t)); |
| addr = base + (2<<2); |
| HSL_REG_ENTRY_GEN_SET(rv, dev_id, addr, sizeof (a_uint32_t), |
| (a_uint8_t *) (&act[2]), sizeof (a_uint32_t)); |
| MULTI_DEBUG("pos=%d, before sync portmap, the new act=%x %x\n", pos, act[1],act[2]); |
| if((rv = dess_acl_rule_sync_multi_portmap(dev_id, pos, act)) < 0) |
| aos_printk("Sync multicast portmap error\n"); |
| return rv; |
| } |
| |
| HSL_LOCAL int multi_get_dp(void) |
| { |
| a_uint32_t addr; |
| a_uint32_t dev_id=0; |
| sw_error_t rv; |
| int val=0; |
| |
| addr = 0x624;//GLOBAL_FW_CTRL1 |
| HSL_REG_ENTRY_GEN_GET(rv, dev_id, addr, sizeof (a_uint32_t), |
| (a_uint8_t *) (&val), |
| sizeof (a_uint32_t)); |
| if (rv != SW_OK) |
| aos_printk("Get entry value error\n"); |
| |
| val = (val>>24)&0x7f; //30:24, IGMP_JOIN_LEAVE_DP |
| |
| return val; |
| } |
| static int old_bind_p=-1; |
| HSL_LOCAL int multi_acl_bind(void) |
| { |
| int bind_p; |
| int i; |
| |
| bind_p = multi_get_dp(); |
| if(bind_p == old_bind_p) |
| return 0; |
| old_bind_p = bind_p; |
| |
| for(i=0; i<7; i++) |
| { |
| dess_acl_list_unbind(0, FAL_ACL_LIST_MULTICAST, FAL_ACL_DIREC_IN, FAL_ACL_BIND_PORT, i); |
| dess_acl_list_unbind(0, FAL_ACL_LIST_MULTICAST+1, FAL_ACL_DIREC_IN, FAL_ACL_BIND_PORT, i); |
| } |
| |
| if(bind_p==0) |
| { |
| for(i=0; i<7; i++) |
| { |
| dess_acl_list_bind(0, FAL_ACL_LIST_MULTICAST, FAL_ACL_DIREC_IN, FAL_ACL_BIND_PORT, i); |
| dess_acl_list_bind(0, FAL_ACL_LIST_MULTICAST+1, FAL_ACL_DIREC_IN, FAL_ACL_BIND_PORT, i); |
| } |
| } |
| else |
| { |
| for(i=0; i<7; i++) |
| if((bind_p>>i) &0x1) |
| { |
| dess_acl_list_bind(0, FAL_ACL_LIST_MULTICAST, FAL_ACL_DIREC_IN, FAL_ACL_BIND_PORT, i); |
| dess_acl_list_bind(0, FAL_ACL_LIST_MULTICAST+1, FAL_ACL_DIREC_IN, FAL_ACL_BIND_PORT, i); |
| } |
| else |
| continue; |
| } |
| return 0; |
| } |
| /* |
| ** Only update the related portmap from the privious input. |
| */ |
| HSL_LOCAL sw_error_t dess_multicast_acl_update( int list_id, int acl_index, fal_igmp_sg_entry_t * entry, int action) |
| { |
| a_uint32_t dev_id=0; |
| a_uint32_t rule_pos; |
| sw_error_t rv = SW_OK; |
| |
| if(acl_index<0) |
| { |
| aos_printk("Something is wrong...\n"); |
| return SW_FAIL; |
| } |
| |
| rule_pos = dess_acl_rule_get_offset(dev_id, list_id, multi_acl_group[acl_index].index); |
| if(MULT_ACTION_SET == action) |
| { |
| multi_acl_group[acl_index].entry.port_map |= entry->port_map; |
| if(entry->port_map == 0) |
| { |
| multi_acl_group[acl_index].entry.port_map = 0; |
| } |
| } |
| else if(MULT_ACTION_CLEAR == action) |
| multi_acl_group[acl_index].entry.port_map &= ~(entry->port_map); |
| |
| rv = multi_portmap_aclreg_set_all(rule_pos, &multi_acl_group[acl_index].entry); |
| |
| multi_acl_bind(); //Here need extra bind since IGMP join/leave would happen |
| return rv; |
| } |
| |
| HSL_LOCAL sw_error_t dess_multicast_acl_del(int list_id, int index) |
| { |
| sw_error_t rv; |
| int rule_id; |
| |
| rule_id = multi_acl_group[index].index; |
| |
| rv = dess_acl_rule_delete(0, list_id, rule_id, 1); |
| multi_acl_bind(); //Here need extra bind since IGMP join/leave would happen |
| return rv; |
| } |
| |
| /* |
| ** Add new acl rule with parameters: DIP, SIP, redirect port. |
| */ |
| HSL_LOCAL sw_error_t dess_multicast_acl_add(int list_id, fal_igmp_sg_entry_t * entry) |
| { |
| sw_error_t val; |
| a_uint32_t pos; |
| fal_acl_rule_t acl= {0}; |
| |
| /* IPv4 multicast */ |
| if( entry->group.type == FAL_ADDR_IPV4 ) |
| { |
| MULTI_DEBUG("KKK1, group[%d][%x], source[%d][%x]\n",entry->group.type, |
| entry->group.u.ip4_addr, entry->source.type, entry->source.u.ip4_addr); |
| |
| acl.rule_type = FAL_ACL_RULE_IP4; |
| |
| if(entry->group.u.ip4_addr!= 0) |
| { |
| acl.dest_ip4_val = entry->group.u.ip4_addr; |
| acl.dest_ip4_mask = 0xffffffff;//e->ip.dmsk.s_addr; |
| FAL_FIELD_FLG_SET(acl.field_flg, FAL_ACL_FIELD_IP4_DIP); |
| } |
| if(entry->source.u.ip4_addr!= 0) |
| { |
| acl.src_ip4_val = entry->source.u.ip4_addr; |
| acl.src_ip4_mask = 0xffffffff;//e->ip.smsk.s_addr; |
| FAL_FIELD_FLG_SET(acl.field_flg, FAL_ACL_FIELD_IP4_SIP); |
| } |
| if( entry->port_map==0 ) |
| FAL_ACTION_FLG_SET ( acl.action_flg, FAL_ACL_ACTION_DENY); |
| else |
| //FAL_FIELD_FLG_SET(acl.field_flg, FAL_ACL_FIELD_INVERSE_ALL); |
| FAL_ACTION_FLG_SET ( acl.action_flg, FAL_ACL_ACTION_PERMIT ); |
| |
| /* Be careful, _dess_acl_action_parse() will block FAL_ACL_ACTION_DENY action, So we change it. */ |
| if( entry->port_map ) |
| { |
| FAL_ACTION_FLG_SET(acl.action_flg, FAL_ACL_ACTION_REDPT); |
| acl.ports = entry->port_map; |
| } |
| } |
| else if( entry->group.type == FAL_ADDR_IPV6 ) |
| { |
| MULTI_DEBUG("KKK2, group[%d][%x], source[%d][%x], pm=%x\n",entry->group.type, |
| entry->group.u.ip6_addr.ul[0], entry->source.type, entry->source.u.ip6_addr.ul[0], entry->port_map); |
| |
| acl.rule_type = FAL_ACL_RULE_IP6; |
| |
| if(!ip6_addr_is_null(&(entry->group.u.ip6_addr))) |
| { |
| memcpy(&acl.dest_ip6_val, &(entry->group.u.ip6_addr), sizeof(entry->group.u.ip6_addr)); |
| acl.dest_ip6_mask.ul[0] = 0xffffffff; |
| acl.dest_ip6_mask.ul[1] = 0xffffffff; |
| acl.dest_ip6_mask.ul[2] = 0xffffffff; |
| acl.dest_ip6_mask.ul[3] = 0xffffffff; |
| FAL_FIELD_FLG_SET(acl.field_flg, FAL_ACL_FIELD_IP6_DIP); |
| } |
| if(!ip6_addr_is_null(&(entry->source.u.ip6_addr))) |
| { |
| memcpy(&acl.src_ip6_val, &(entry->source.u.ip6_addr), sizeof(entry->source.u.ip6_addr)); |
| acl.src_ip6_mask.ul[0] = 0xffffffff; |
| acl.src_ip6_mask.ul[1] = 0xffffffff; |
| acl.src_ip6_mask.ul[2] = 0xffffffff; |
| acl.src_ip6_mask.ul[3] = 0xffffffff; |
| FAL_FIELD_FLG_SET(acl.field_flg, FAL_ACL_FIELD_IP6_SIP); |
| } |
| |
| if( entry->port_map==0 ) |
| FAL_ACTION_FLG_SET ( acl.action_flg, FAL_ACL_ACTION_DENY); |
| else |
| //FAL_FIELD_FLG_SET(acl.field_flg, FAL_ACL_FIELD_INVERSE_ALL); |
| FAL_ACTION_FLG_SET ( acl.action_flg, FAL_ACL_ACTION_PERMIT ); |
| |
| /* Be careful, _dess_acl_action_parse() will block FAL_ACL_ACTION_DENY action, So we change it. */ |
| if( entry->port_map ) |
| { |
| FAL_ACTION_FLG_SET(acl.action_flg, FAL_ACL_ACTION_REDPT); |
| acl.ports = entry->port_map; |
| } |
| } |
| |
| if (entry->vlan_id < 4096) |
| { |
| FAL_FIELD_FLG_SET(acl.field_flg, FAL_ACL_FIELD_MAC_VID); |
| acl.vid_val = entry->vlan_id; |
| acl.vid_op = FAL_ACL_FIELD_MASK; |
| acl.vid_mask = 0xfff; |
| } |
| |
| pos = dess_multicast_acl_total_n(list_id); |
| |
| MULTI_DEBUG("In dess_multicast_acl_add, list_id=%d, rule_id=%d\n", list_id, pos); |
| val = dess_acl_rule_add(0, list_id, pos, mul_rule_nr, &acl); |
| |
| multi_acl_bind(); |
| |
| return val; |
| } |
| |
| |
| HSL_LOCAL int iterate_multicast_acl_group(a_uint32_t number, fal_igmp_sg_entry_t * entry) |
| { |
| int count=0; |
| int i; |
| |
| if (number == 0) |
| return 0; //no any ACL rules based the query |
| |
| for(i=0; i<number; i++) |
| { |
| |
| /*MULTI_DEBUG("2:iterate_multicast_acl_group, index=%d, multi_acl_info[%d].entry=type[%d]-addr[%x], pm=%x, new entry=type[%d]-addr[%x], pm=%x\n", |
| multi_acl_info[i].index,i, multi_acl_info[i].entry.group.type, multi_acl_info[i].entry.group.u.ip6_addr.ul[0], multi_acl_info[i].entry.port_map, |
| entry->group.type, entry->group.u.ip6_addr.ul[0], entry->port_map);*/ |
| |
| if(0 == memcmp(&(multi_acl_info[i].entry.group), &(entry->group), sizeof(entry->group))) |
| { |
| memcpy(&multi_acl_group[count], &multi_acl_info[i], sizeof(multi_acl_info[i])); |
| count++;//return the real number of multi_acl_group[] |
| MULTI_DEBUG("in iterate_multicast_acl_group, count=%d, i=%d\n", count, i); |
| } |
| } |
| |
| return count; |
| } |
| |
| HSL_LOCAL int mult_acl_has_entry(fal_igmp_sg_addr_t * group, fal_igmp_sg_addr_t *source) |
| { |
| int rule_id; |
| int ret = 0; |
| #if 0 |
| if(source != NULL) |
| { |
| MULTI_DEBUG("new group[%d]= %x %x %x %x, new source[%d]=%x %x %x %x\n", |
| group->type, group->u.ip6_addr.ul[0], group->u.ip6_addr.ul[1], group->u.ip6_addr.ul[2], group->u.ip6_addr.ul[3], |
| source->type, source->u.ip6_addr.ul[0], source->u.ip6_addr.ul[1], source->u.ip6_addr.ul[2], source->u.ip6_addr.ul[3]); |
| |
| MULTI_DEBUG("old group[%d]= %x %x %x %x, old source[%d]=%x %x %x %x\n", |
| multi_acl_group[0].entry.group.type, multi_acl_group[0].entry.group.u.ip6_addr.ul[0], |
| multi_acl_group[0].entry.group.u.ip6_addr.ul[1], multi_acl_group[0].entry.group.u.ip6_addr.ul[2], multi_acl_group[0].entry.group.u.ip6_addr.ul[3], |
| multi_acl_group[0].entry.source.type, multi_acl_group[0].entry.source.u.ip6_addr.ul[0], |
| multi_acl_group[0].entry.source.u.ip6_addr.ul[1], multi_acl_group[0].entry.source.u.ip6_addr.ul[2], multi_acl_group[0].entry.source.u.ip6_addr.ul[3]); |
| } |
| #endif |
| if(source == NULL) |
| { |
| for(rule_id=0; rule_id<FAL_IGMP_SG_ENTRY_MAX; rule_id++) |
| { |
| if( (0==memcmp(&multi_acl_group[rule_id].entry.group, group, sizeof(fal_igmp_sg_addr_t))) && |
| (multi_source_is_null(&multi_acl_group[rule_id].entry.source))) |
| { |
| MULTI_DEBUG("Source=0:Orignal ACL rule have this entry! rule id= %d\n", rule_id); |
| ret = rule_id+1; // ensure the return value is the actually number of entry |
| break; |
| } |
| } |
| } |
| else |
| { |
| for(rule_id=0; rule_id<FAL_IGMP_SG_ENTRY_MAX; rule_id++) |
| { |
| if( (0==memcmp(&multi_acl_group[rule_id].entry.group, group, sizeof(fal_igmp_sg_addr_t))) && |
| (0==memcmp(&multi_acl_group[rule_id].entry.source, source, sizeof(fal_igmp_sg_addr_t)))) |
| { |
| MULTI_DEBUG("Orignal ACL rule have this entry! rule id= %d\n", rule_id); |
| ret = rule_id+1; // ensure the return value is the actually number of entry |
| break; |
| } |
| } |
| } |
| |
| return ret; |
| } |
| HSL_LOCAL int portmap_null(int index, fal_pbmp_t portmap) |
| { |
| int val; |
| if (index<0) |
| { |
| aos_printk("portmap_null, index error\n"); |
| return SW_FAIL; |
| } |
| val = multi_acl_group[index].entry.port_map&(~portmap); |
| |
| if( 0 == (val&0xff) ) |
| return 1; |
| else |
| return 0; |
| } |
| |
| HSL_LOCAL int portmap_valid(fal_igmp_sg_entry_t *g_source, fal_igmp_sg_entry_t *g_star) |
| { |
| /* return 0 means the portmap is Not valid |
| return 1 means the protmap is valid |
| */ |
| /* MULTI_DEBUG("portmap_valid:g_source portmap=%x, source=%x,group=%x, g_star portmap=%x, source=%x, group=%x\n", |
| g_source->port_map, g_source->source.u.ip4_addr, g_source->group.u.ip4_addr, |
| g_star->port_map, g_star->source.u.ip4_addr,g_star->group.u.ip4_addr);*/ |
| |
| if(multi_source_is_null(&(g_star->source))) |
| { |
| if((g_source->port_map|g_star->port_map) == g_star->port_map) |
| { |
| return 0; |
| } |
| } |
| |
| return 1; |
| } |
| |
| |
| HSL_LOCAL int portmap_clear_type(int count, int index, fal_pbmp_t portmap) |
| { |
| if(count>=0 && index<count) //new_index must >0; this means there're (G,*) and (G,S) |
| { |
| //if the new clear portmap will cause (G,S)=(G,*), Delete the (G,S) |
| if((multi_acl_group[index].entry.port_map & (~portmap)) == multi_acl_group[count].entry.port_map) |
| return 1; //delete |
| |
| |
| //The following means there must be at least one bit clear wrong. Clear the (G,*) portmap. |
| if( ((multi_acl_group[index].entry.port_map & (~portmap)) & (multi_acl_group[count].entry.port_map)) |
| != (multi_acl_group[count].entry.port_map)) |
| return 0; |
| |
| return 2; //Normal update |
| } |
| return 0; |
| } |
| sw_error_t dess_igmp_sg_entry_set(a_uint32_t dev_id, fal_igmp_sg_entry_t * entry) |
| { |
| int number, count; |
| int new_index=0; |
| sw_error_t rv; |
| int action = MULT_ACTION_SET; |
| int i=0; |
| |
| HSL_API_LOCK; |
| (void)dess_multicast_init(0); |
| aos_mem_zero(multi_acl_info, FAL_IGMP_SG_ENTRY_MAX * sizeof (multi_acl_info_t)); |
| aos_mem_zero(multi_acl_group, FAL_IGMP_SG_ENTRY_MAX * sizeof (multi_acl_info_t)); |
| MULTI_DEBUG("Before query: group=%x, source=%x, portmap=%x\n", entry->group.u.ip4_addr, entry->source.u.ip4_addr, entry->port_map); |
| //number is the total multicast ACL rules amount, stores in multi_acl_info[]; |
| number = dess_multicast_acl_query(); |
| |
| if(number > FAL_IGMP_SG_ENTRY_MAX) |
| return SW_FAIL; |
| //count the total specific multicast group ACL rules, stores in multi_acl_group[]; count <=number |
| count = iterate_multicast_acl_group(number, entry); |
| //new_index-1 is the found entry index in multi_acl_group[], the real index is [new_index-1], 0 means no entry |
| new_index = mult_acl_has_entry(&entry->group, &entry->source); |
| |
| MULTI_DEBUG("Start entry set: number=%d, count=%d, new_index=%d, pm=%x\n", number, count, new_index, entry->port_map); |
| if( 0==multi_source_is_null(&entry->source) ) // new entry is (G, S) |
| { |
| MULTI_DEBUG("the new entry is (G,S)\n"); |
| if(count>0 && 0 == portmap_valid(entry, &(multi_acl_group[count-1].entry))) //specfic group entry exist,(G,S) or (G,*) |
| { |
| //return SW_NO_CHANGE; // The new portmap is Not valid |
| MULTI_DEBUG("KKK, modified 1 !!!\n"); |
| } |
| |
| if(0 == new_index) //new entry, need add |
| { |
| #if 0 |
| /*The method: |
| 1. predict if the portmap should be modified. |
| 2. add new acl rule with new portmap value. |
| */ |
| if((tmp_index = mult_acl_has_entry(&entry->group, NULL))>0) // (G, *) entry exist |
| { |
| /*Here the update should new (G, S) OR orignal (G,*) portmap, |
| be careful, entry's portmap value will be modified, so I use tmp_entry. |
| */ |
| memcpy(tmp_entry, entry, sizeof(fal_igmp_sg_entry_t)); |
| MULTI_DEBUG("Here, (G,*) exist! tmp_index=%d\n", tmp_index); |
| sw_multicast_acl_update(FAL_ACL_LIST_MULTICAST+1, tmp_index-1, tmp_entry, action); |
| |
| dess_multicast_acl_add(FAL_ACL_LIST_MULTICAST, tmp_entry); |
| return SW_OK; |
| } |
| #endif |
| dess_multicast_acl_add(FAL_ACL_LIST_MULTICAST, entry); |
| MULTI_DEBUG("Here, need add (G, S), portmap=%x\n", entry->port_map); |
| return SW_OK; |
| } |
| else |
| { |
| //Here update Just: the old exist entry portmap OR the new entry portmap |
| dess_multicast_acl_update(FAL_ACL_LIST_MULTICAST, new_index-1, entry, action); |
| return SW_OK; |
| } |
| } //end of memcmp |
| else // new entry is (G, *) |
| { |
| if(0 == new_index) //new entry, need add |
| { |
| dess_multicast_acl_add(FAL_ACL_LIST_MULTICAST+1, entry); |
| rv = SW_OK; |
| } |
| else if(new_index > 0) // (G, *) entry exist? |
| { |
| //Update exist (G, *) portmap with new portmap |
| MULTI_DEBUG("(G,*) exist, before update, new_index=%d\n", new_index ); |
| dess_multicast_acl_update(FAL_ACL_LIST_MULTICAST+1, new_index-1, entry, action); |
| rv = SW_OK; |
| } |
| |
| if(new_index>0&&count>1) //(G,S*) and (G,*) exist, new entry is (G,*) |
| { |
| for(i=count-2; i>=0&&i<FAL_IGMP_SG_ENTRY_MAX; i--) |
| { |
| if(multi_acl_group[i].entry.port_map==0) //This ACL rule should be done nothing, DENY rule |
| continue; |
| |
| if(0 == portmap_valid(&(multi_acl_group[i].entry), &(multi_acl_group[count-1].entry))) |
| { |
| MULTI_DEBUG("1:portmap is not valid, should delete, i=%d, source portmap=%x, gstar pm=%x\n", |
| i, multi_acl_group[i].entry.port_map, multi_acl_group[count-1].entry.port_map); |
| dess_multicast_acl_del(FAL_ACL_LIST_MULTICAST, i); |
| rv = SW_NO_MORE; |
| } |
| else |
| { |
| MULTI_DEBUG("1:Start update all (G,S),i=%d, gstar portmap=%x\n", i, multi_acl_group[count-1].entry.port_map); |
| //Update all (G,S) entry portmap with new(G, *) portmap |
| dess_multicast_acl_update(FAL_ACL_LIST_MULTICAST, i, entry, action); |
| rv = SW_OK; |
| } |
| } |
| } |
| else if(new_index==0&&count>0) //only exist (G,S*) orignally |
| { |
| for(i=count-1; i>=0&&i<FAL_IGMP_SG_ENTRY_MAX; i--) |
| { |
| if(multi_acl_group[i].entry.port_map==0) //This ACL rule should be done nothing, DENY rule |
| continue; |
| |
| if(0 == portmap_valid(&(multi_acl_group[i].entry), entry)) |
| { |
| MULTI_DEBUG("2:portmap is not valid, should delete, i=%d, source portmap=%x, gstar pm=%x\n", |
| i, multi_acl_group[i].entry.port_map, entry->port_map); |
| dess_multicast_acl_del(FAL_ACL_LIST_MULTICAST, i); |
| rv = SW_NO_MORE; |
| } |
| else |
| { |
| MULTI_DEBUG("2:Start update all (G,S),i=%d, portmap=%x\n", i, entry->port_map); |
| //Update all (G,S) entry portmap with new(G, *) portmap |
| dess_multicast_acl_update(FAL_ACL_LIST_MULTICAST, i, entry, action); |
| rv = SW_OK; |
| } |
| } |
| } |
| } |
| HSL_API_UNLOCK; |
| return rv; |
| } |
| |
| sw_error_t dess_igmp_sg_entry_clear(a_uint32_t dev_id, fal_igmp_sg_entry_t * entry) |
| { |
| a_uint32_t number, count; |
| int new_index=0; |
| sw_error_t rv = SW_OK; |
| int action= MULT_ACTION_CLEAR; |
| int i=0; |
| int pm_type; |
| |
| HSL_API_LOCK; |
| (void)dess_multicast_init(0); |
| aos_mem_zero(multi_acl_info, FAL_IGMP_SG_ENTRY_MAX * sizeof (multi_acl_info_t)); |
| aos_mem_zero(multi_acl_group, FAL_IGMP_SG_ENTRY_MAX * sizeof (multi_acl_info_t)); |
| //number is the total multicast ACL rules amount, stores in multi_acl_info[]; |
| number = dess_multicast_acl_query(); |
| if(number > FAL_IGMP_SG_ENTRY_MAX) |
| return SW_FAIL; |
| //count the total specific multicast group ACL rules, stores in multi_acl_group[]; count <=number |
| count = iterate_multicast_acl_group(number, entry); |
| if(count == 0) |
| return SW_OK; |
| //new_index-1 is the found entry index in multi_acl_group[] |
| new_index = mult_acl_has_entry(&entry->group, &entry->source); |
| |
| MULTI_DEBUG("Start entry clear: number=%d, count=%d, new_index=%d\n", number, count, new_index); |
| if(0 == new_index || new_index > FAL_IGMP_SG_ENTRY_MAX || count > FAL_IGMP_SG_ENTRY_MAX) //new entry, the user command is wrong |
| { |
| return SW_NO_SUCH; |
| } |
| |
| if( 0==multi_source_is_null(&entry->source) ) // new entry is (G, S) |
| { |
| if (portmap_null(new_index-1, entry->port_map)) |
| { |
| MULTI_DEBUG("KKK entry clear, new(G,S), with null portmap. \n"); |
| dess_multicast_acl_del(FAL_ACL_LIST_MULTICAST, new_index-1); |
| return SW_OK; |
| } |
| else |
| { |
| MULTI_DEBUG("KKK entry clear, new(G,S), with NOT null portmap. \n"); |
| /* If (G,*) doesn't exist, [count-1] is the last specfic group, maybe(G,*) */ |
| if(0 == multi_source_is_null(&(multi_acl_group[count-1].entry.source))) |
| { |
| dess_multicast_acl_update(FAL_ACL_LIST_MULTICAST, new_index-1, entry, action); |
| } |
| else //(G,*) exist |
| { |
| pm_type = portmap_clear_type(count-1, new_index-1, entry->port_map); |
| if(pm_type == 0) |
| return SW_NO_CHANGE; |
| else if(pm_type == 1) |
| { |
| dess_multicast_acl_del(FAL_ACL_LIST_MULTICAST, new_index-1); |
| return SW_OK; |
| } |
| else |
| { |
| //normal update; consider here...wangson |
| dess_multicast_acl_update(FAL_ACL_LIST_MULTICAST, new_index-1, entry, action); |
| } |
| } |
| } |
| return SW_OK; |
| } |
| else //clear entry is (G,*) |
| { |
| MULTI_DEBUG("Here, new_index[%d]>=0, new portmap to clear is %x\n", new_index, entry->port_map); |
| if (portmap_null(new_index-1, entry->port_map)) |
| { |
| dess_multicast_acl_del(FAL_ACL_LIST_MULTICAST+1, new_index-1); |
| rv = SW_OK; |
| } |
| else |
| { |
| MULTI_DEBUG("Update (G,*)!, new_index=%d, pm=%x\n", new_index, entry->port_map); |
| dess_multicast_acl_update(FAL_ACL_LIST_MULTICAST+1, new_index-1, entry, action); |
| } |
| MULTI_DEBUG("KKK, ready clear (G, S*), count=%d\n", count); |
| #if 0 |
| if(count>1) // (G, S*) entry exist, if count=1 here, only exist(G,*)entry |
| { |
| //count must >=2 |
| for(i=count-2; i>=0; i--) |
| { |
| if(portmap_null(i, entry->port_map)) |
| { |
| MULTI_DEBUG("portmap_null, i=%d\n", i); |
| dess_multicast_acl_del(FAL_ACL_LIST_MULTICAST, i); |
| rv = SW_NO_MORE; |
| } |
| else |
| { |
| //Update all (G,S) entry portmap with new(G, *) portmap |
| dess_multicast_acl_update(FAL_ACL_LIST_MULTICAST, i, entry, action); |
| rv = SW_OK; |
| } |
| } |
| } |
| #else |
| if(count>1) // (G, S*) entry exist, if count=1 here, only exist(G,*)entry |
| { |
| //count must >=2 |
| for(i=count-2; i>=0&&i<FAL_IGMP_SG_ENTRY_MAX; i--) |
| { |
| //PortMap of entry (S,G) == (*,G) portmap after clear? |
| if((multi_acl_group[new_index-1].entry.port_map&(~(entry->port_map))) == |
| multi_acl_group[i].entry.port_map) |
| dess_multicast_acl_del(FAL_ACL_LIST_MULTICAST, i); |
| else |
| //Update all (G,S) entry portmap with new(G, *) portmap |
| dess_multicast_acl_update(FAL_ACL_LIST_MULTICAST, i, entry, action); |
| rv = SW_OK; |
| } |
| } |
| #endif |
| } |
| HSL_API_UNLOCK; |
| return rv; |
| } |
| |
| static void |
| print_ip4addr(char * param_name, a_uint32_t * buf, |
| a_uint32_t size) |
| { |
| a_uint32_t i; |
| fal_ip4_addr_t ip4; |
| |
| ip4 = *((fal_ip4_addr_t *) buf); |
| aos_printk("%s", param_name); |
| for (i = 0; i < 3; i++) |
| { |
| aos_printk("%d.", (ip4 >> (24 - i * 8)) & 0xff); |
| } |
| aos_printk("%d", (ip4 & 0xff)); |
| } |
| static void |
| print_ip6addr(char * param_name, a_uint32_t * buf, |
| a_uint32_t size) |
| { |
| a_uint32_t i; |
| fal_ip6_addr_t ip6; |
| |
| ip6 = *(fal_ip6_addr_t *) buf; |
| aos_printk("%s", param_name); |
| for (i = 0; i < 3; i++) |
| { |
| aos_printk("%x:%x:", (ip6.ul[i] >> 16) & 0xffff, ip6.ul[i] & 0xffff); |
| } |
| aos_printk("%x:%x", (ip6.ul[3] >> 16) & 0xffff, ip6.ul[3] & 0xffff); |
| } |
| sw_error_t dess_igmp_sg_entry_show(a_uint32_t dev_id) |
| { |
| a_uint32_t number; |
| int i; |
| |
| HSL_API_LOCK; |
| (void)dess_multicast_init(0); |
| aos_mem_zero(multi_acl_info, FAL_IGMP_SG_ENTRY_MAX * sizeof (multi_acl_info_t)); |
| aos_mem_zero(multi_acl_group, FAL_IGMP_SG_ENTRY_MAX * sizeof (multi_acl_info_t)); |
| //number is the total multicast ACL rules amount, stores in multi_acl_info[]; |
| number = dess_multicast_acl_query(); |
| |
| for(i=0; i<number; i++) |
| { |
| if(0 == multi_acl_info[i].entry.group.type) //ipv4 |
| { |
| aos_printk("\n[%d]:", i); |
| print_ip4addr(" [Group IPv4 addr]:", (a_uint32_t *)&(multi_acl_info[i].entry.group.u.ip4_addr), sizeof (fal_ip4_addr_t)); |
| print_ip4addr(" [Source IPv4 addr]:", (a_uint32_t *)&(multi_acl_info[i].entry.source.u.ip4_addr), sizeof (fal_ip4_addr_t)); |
| aos_printk("\n [Portmap]: 0x%x ", multi_acl_info[i].entry.port_map); |
| aos_printk(" [Vlanid]: %d ", multi_acl_info[i].entry.vlan_id); |
| } |
| else if(1 == multi_acl_info[i].entry.group.type) //ipv6 |
| { |
| aos_printk("\n[%d]:", i); |
| print_ip6addr(" [Group IPv6 addr]: ", (a_uint32_t *)&(multi_acl_info[i].entry.group.u.ip6_addr), sizeof (fal_ip6_addr_t)); |
| print_ip6addr(" [Source IPv6 addr]: ", (a_uint32_t *)&(multi_acl_info[i].entry.source.u.ip6_addr), sizeof (fal_ip6_addr_t)); |
| aos_printk("\n [Portmap]: 0x%x ", multi_acl_info[i].entry.port_map); |
| aos_printk(" [Vlanid]: %d ", multi_acl_info[i].entry.vlan_id); |
| } |
| |
| } |
| aos_printk("\n\nTotal %d multicast ACL rules.\n", number); |
| HSL_API_UNLOCK; |
| |
| return SW_OK; |
| } |
| |
| void |
| dess_multicast_init(a_uint32_t dev_id) |
| { |
| sw_error_t val; |
| |
| dess_acl_status_set(0, 1); |
| |
| val = dess_acl_list_creat(0, FAL_ACL_LIST_MULTICAST, FAL_MULTICAST_PRI); |
| if(val !=SW_OK && val != SW_ALREADY_EXIST) |
| aos_printk("Multicast 1 acl list create error, val=%d\n", val); |
| |
| val = dess_acl_list_creat(0, FAL_ACL_LIST_MULTICAST+1, FAL_MULTICAST_PRI+1); |
| if(val !=SW_OK && val != SW_ALREADY_EXIST) |
| aos_printk("Multicast 2 acl list create error, val=%d\n", val); |
| |
| } |
| |
| sw_error_t dess_igmp_sg_entry_query(a_uint32_t dev_id, fal_igmp_sg_info_t *info) |
| { |
| a_uint32_t number; |
| int i; |
| |
| HSL_API_LOCK; |
| dess_multicast_init(0); |
| aos_mem_zero(multi_acl_info, FAL_IGMP_SG_ENTRY_MAX * sizeof (multi_acl_info_t)); |
| /*number is the total multicast ACL rules amount, stores in multi_acl_info[];*/ |
| number = dess_multicast_acl_query(); |
| if(number > FAL_IGMP_SG_ENTRY_MAX) |
| { |
| HSL_API_UNLOCK; |
| return SW_FAIL; |
| } |
| info->cnt = number; |
| |
| for(i=0; i<number; i++) |
| { |
| aos_mem_copy(&(info->acl_info[i]), &(multi_acl_info[i]), sizeof(multi_acl_info_t)); |
| } |
| HSL_API_UNLOCK; |
| |
| return SW_OK; |
| } |
| |
