struct tc_action_ops {
        struct list_head head;
        char    kind[IFNAMSIZ];
-       __u32   type; /* TBD to match kind */
+       enum tca_id  id; /* identifier should match kind */
        size_t  size;
        struct module           *owner;
        int     (*act)(struct sk_buff *, const struct tc_action *,
 
 static inline bool is_tcf_csum(const struct tc_action *a)
 {
 #ifdef CONFIG_NET_CLS_ACT
-       if (a->ops && a->ops->type == TCA_ACT_CSUM)
+       if (a->ops && a->ops->id == TCA_ID_CSUM)
                return true;
 #endif
        return false;
 
 #ifdef CONFIG_NET_CLS_ACT
        struct tcf_gact *gact;
 
-       if (a->ops && a->ops->type != TCA_ACT_GACT)
+       if (a->ops && a->ops->id != TCA_ID_GACT)
                return false;
 
        gact = to_gact(a);
 
 static inline bool is_tcf_mirred_egress_redirect(const struct tc_action *a)
 {
 #ifdef CONFIG_NET_CLS_ACT
-       if (a->ops && a->ops->type == TCA_ACT_MIRRED)
+       if (a->ops && a->ops->id == TCA_ID_MIRRED)
                return to_mirred(a)->tcfm_eaction == TCA_EGRESS_REDIR;
 #endif
        return false;
 static inline bool is_tcf_mirred_egress_mirror(const struct tc_action *a)
 {
 #ifdef CONFIG_NET_CLS_ACT
-       if (a->ops && a->ops->type == TCA_ACT_MIRRED)
+       if (a->ops && a->ops->id == TCA_ID_MIRRED)
                return to_mirred(a)->tcfm_eaction == TCA_EGRESS_MIRROR;
 #endif
        return false;
 
 static inline bool is_tcf_pedit(const struct tc_action *a)
 {
 #ifdef CONFIG_NET_CLS_ACT
-       if (a->ops && a->ops->type == TCA_ACT_PEDIT)
+       if (a->ops && a->ops->id == TCA_ID_PEDIT)
                return true;
 #endif
        return false;
 
 static inline bool is_tcf_sample(const struct tc_action *a)
 {
 #ifdef CONFIG_NET_CLS_ACT
-       return a->ops && a->ops->type == TCA_ACT_SAMPLE;
+       return a->ops && a->ops->id == TCA_ID_SAMPLE;
 #else
        return false;
 #endif
 
 #ifdef CONFIG_NET_CLS_ACT
        u32 flags;
 
-       if (a->ops && a->ops->type == TCA_ACT_SKBEDIT) {
+       if (a->ops && a->ops->id == TCA_ID_SKBEDIT) {
                rcu_read_lock();
                flags = rcu_dereference(to_skbedit(a)->params)->flags;
                rcu_read_unlock();
 
        struct tcf_tunnel_key *t = to_tunnel_key(a);
        struct tcf_tunnel_key_params *params = rtnl_dereference(t->params);
 
-       if (a->ops && a->ops->type == TCA_ACT_TUNNEL_KEY)
+       if (a->ops && a->ops->id == TCA_ID_TUNNEL_KEY)
                return params->tcft_action == TCA_TUNNEL_KEY_ACT_SET;
 #endif
        return false;
        struct tcf_tunnel_key *t = to_tunnel_key(a);
        struct tcf_tunnel_key_params *params = rtnl_dereference(t->params);
 
-       if (a->ops && a->ops->type == TCA_ACT_TUNNEL_KEY)
+       if (a->ops && a->ops->id == TCA_ID_TUNNEL_KEY)
                return params->tcft_action == TCA_TUNNEL_KEY_ACT_RELEASE;
 #endif
        return false;
 
 static inline bool is_tcf_vlan(const struct tc_action *a)
 {
 #ifdef CONFIG_NET_CLS_ACT
-       if (a->ops && a->ops->type == TCA_ACT_VLAN)
+       if (a->ops && a->ops->id == TCA_ID_VLAN)
                return true;
 #endif
        return false;
 
 #define TCA_ACT_SAMPLE 26
 
 /* Action type identifiers*/
-enum {
+enum tca_id {
        TCA_ID_UNSPEC = 0,
        TCA_ID_POLICE = 1,
        TCA_ID_GACT = TCA_ACT_GACT,
 
 
        write_lock(&act_mod_lock);
        list_for_each_entry(a, &act_base, head) {
-               if (act->type == a->type || (strcmp(act->kind, a->kind) == 0)) {
+               if (act->id == a->id || (strcmp(act->kind, a->kind) == 0)) {
                        write_unlock(&act_mod_lock);
                        unregister_pernet_subsys(ops);
                        return -EEXIST;
 
 
 static struct tc_action_ops act_bpf_ops __read_mostly = {
        .kind           =       "bpf",
-       .type           =       TCA_ACT_BPF,
+       .id             =       TCA_ID_BPF,
        .owner          =       THIS_MODULE,
        .act            =       tcf_bpf_act,
        .dump           =       tcf_bpf_dump,
 
 
 static struct tc_action_ops act_connmark_ops = {
        .kind           =       "connmark",
-       .type           =       TCA_ACT_CONNMARK,
+       .id             =       TCA_ID_CONNMARK,
        .owner          =       THIS_MODULE,
        .act            =       tcf_connmark_act,
        .dump           =       tcf_connmark_dump,
 
 
 static struct tc_action_ops act_csum_ops = {
        .kind           = "csum",
-       .type           = TCA_ACT_CSUM,
+       .id             = TCA_ID_CSUM,
        .owner          = THIS_MODULE,
        .act            = tcf_csum_act,
        .dump           = tcf_csum_dump,
 
 
 static struct tc_action_ops act_gact_ops = {
        .kind           =       "gact",
-       .type           =       TCA_ACT_GACT,
+       .id             =       TCA_ID_GACT,
        .owner          =       THIS_MODULE,
        .act            =       tcf_gact_act,
        .stats_update   =       tcf_gact_stats_update,
 
 
 static struct tc_action_ops act_ife_ops = {
        .kind = "ife",
-       .type = TCA_ACT_IFE,
+       .id = TCA_ID_IFE,
        .owner = THIS_MODULE,
        .act = tcf_ife_act,
        .dump = tcf_ife_dump,
 
 
 static struct tc_action_ops act_ipt_ops = {
        .kind           =       "ipt",
-       .type           =       TCA_ACT_IPT,
+       .id             =       TCA_ID_IPT,
        .owner          =       THIS_MODULE,
        .act            =       tcf_ipt_act,
        .dump           =       tcf_ipt_dump,
 
 static struct tc_action_ops act_xt_ops = {
        .kind           =       "xt",
-       .type           =       TCA_ACT_XT,
+       .id             =       TCA_ID_XT,
        .owner          =       THIS_MODULE,
        .act            =       tcf_ipt_act,
        .dump           =       tcf_ipt_dump,
 
 
 static struct tc_action_ops act_mirred_ops = {
        .kind           =       "mirred",
-       .type           =       TCA_ACT_MIRRED,
+       .id             =       TCA_ID_MIRRED,
        .owner          =       THIS_MODULE,
        .act            =       tcf_mirred_act,
        .stats_update   =       tcf_stats_update,
 
 
 static struct tc_action_ops act_nat_ops = {
        .kind           =       "nat",
-       .type           =       TCA_ACT_NAT,
+       .id             =       TCA_ID_NAT,
        .owner          =       THIS_MODULE,
        .act            =       tcf_nat_act,
        .dump           =       tcf_nat_dump,
 
 
 static struct tc_action_ops act_pedit_ops = {
        .kind           =       "pedit",
-       .type           =       TCA_ACT_PEDIT,
+       .id             =       TCA_ID_PEDIT,
        .owner          =       THIS_MODULE,
        .act            =       tcf_pedit_act,
        .dump           =       tcf_pedit_dump,
 
 
 static struct tc_action_ops act_police_ops = {
        .kind           =       "police",
-       .type           =       TCA_ID_POLICE,
+       .id             =       TCA_ID_POLICE,
        .owner          =       THIS_MODULE,
        .act            =       tcf_police_act,
        .dump           =       tcf_police_dump,
 
 
 static struct tc_action_ops act_sample_ops = {
        .kind     = "sample",
-       .type     = TCA_ACT_SAMPLE,
+       .id       = TCA_ID_SAMPLE,
        .owner    = THIS_MODULE,
        .act      = tcf_sample_act,
        .dump     = tcf_sample_dump,
 
 
 static struct tc_action_ops act_simp_ops = {
        .kind           =       "simple",
-       .type           =       TCA_ACT_SIMP,
+       .id             =       TCA_ID_SIMP,
        .owner          =       THIS_MODULE,
        .act            =       tcf_simp_act,
        .dump           =       tcf_simp_dump,
 
 
 static struct tc_action_ops act_skbedit_ops = {
        .kind           =       "skbedit",
-       .type           =       TCA_ACT_SKBEDIT,
+       .id             =       TCA_ID_SKBEDIT,
        .owner          =       THIS_MODULE,
        .act            =       tcf_skbedit_act,
        .dump           =       tcf_skbedit_dump,
 
 
 static struct tc_action_ops act_skbmod_ops = {
        .kind           =       "skbmod",
-       .type           =       TCA_ACT_SKBMOD,
+       .id             =       TCA_ACT_SKBMOD,
        .owner          =       THIS_MODULE,
        .act            =       tcf_skbmod_act,
        .dump           =       tcf_skbmod_dump,
 
 
 static struct tc_action_ops act_tunnel_key_ops = {
        .kind           =       "tunnel_key",
-       .type           =       TCA_ACT_TUNNEL_KEY,
+       .id             =       TCA_ID_TUNNEL_KEY,
        .owner          =       THIS_MODULE,
        .act            =       tunnel_key_act,
        .dump           =       tunnel_key_dump,
 
 
 static struct tc_action_ops act_vlan_ops = {
        .kind           =       "vlan",
-       .type           =       TCA_ACT_VLAN,
+       .id             =       TCA_ID_VLAN,
        .owner          =       THIS_MODULE,
        .act            =       tcf_vlan_act,
        .dump           =       tcf_vlan_dump,