自学教程：C++ tcf_hash_insert函数代码示例

static int tcf_sample_init(struct net *net, struct nlattr *nla,			   struct nlattr *est, struct tc_action **a, int ovr,			   int bind){	struct tc_action_net *tn = net_generic(net, sample_net_id);	struct nlattr *tb[TCA_SAMPLE_MAX + 1];	struct psample_group *psample_group;	struct tc_sample *parm;	struct tcf_sample *s;	bool exists = false;	int ret;	if (!nla)		return -EINVAL;	ret = nla_parse_nested(tb, TCA_SAMPLE_MAX, nla, sample_policy, NULL);	if (ret < 0)		return ret;	if (!tb[TCA_SAMPLE_PARMS] || !tb[TCA_SAMPLE_RATE] ||	    !tb[TCA_SAMPLE_PSAMPLE_GROUP])		return -EINVAL;	parm = nla_data(tb[TCA_SAMPLE_PARMS]);	exists = tcf_hash_check(tn, parm->index, a, bind);	if (exists && bind)		return 0;	if (!exists) {		ret = tcf_hash_create(tn, parm->index, est, a,				      &act_sample_ops, bind, false);		if (ret)			return ret;		ret = ACT_P_CREATED;	} else {		tcf_hash_release(*a, bind);		if (!ovr)			return -EEXIST;	}	s = to_sample(*a);	s->tcf_action = parm->action;	s->rate = nla_get_u32(tb[TCA_SAMPLE_RATE]);	s->psample_group_num = nla_get_u32(tb[TCA_SAMPLE_PSAMPLE_GROUP]);	psample_group = psample_group_get(net, s->psample_group_num);	if (!psample_group) {		if (ret == ACT_P_CREATED)			tcf_hash_release(*a, bind);		return -ENOMEM;	}	RCU_INIT_POINTER(s->psample_group, psample_group);	if (tb[TCA_SAMPLE_TRUNC_SIZE]) {		s->truncate = true;		s->trunc_size = nla_get_u32(tb[TCA_SAMPLE_TRUNC_SIZE]);	}	if (ret == ACT_P_CREATED)		tcf_hash_insert(tn, *a);	return ret;}

static int tcf_simp_init(struct rtattr *rta, struct rtattr *est,			 struct tc_action *a, int ovr, int bind){	struct rtattr *tb[TCA_DEF_MAX];	struct tc_defact *parm;	struct tcf_defact *d;	struct tcf_common *pc;	void *defdata;	u32 datalen = 0;	int ret = 0;	if (rta == NULL || rtattr_parse_nested(tb, TCA_DEF_MAX, rta) < 0)		return -EINVAL;	if (tb[TCA_DEF_PARMS - 1] == NULL ||	    RTA_PAYLOAD(tb[TCA_DEF_PARMS - 1]) < sizeof(*parm))		return -EINVAL;	parm = RTA_DATA(tb[TCA_DEF_PARMS - 1]);	defdata = RTA_DATA(tb[TCA_DEF_DATA - 1]);	if (defdata == NULL)		return -EINVAL;	datalen = RTA_PAYLOAD(tb[TCA_DEF_DATA - 1]);	if (datalen <= 0)		return -EINVAL;	pc = tcf_hash_check(parm->index, a, bind, &simp_hash_info);	if (!pc) {		pc = tcf_hash_create(parm->index, est, a, sizeof(*d), bind,				     &simp_idx_gen, &simp_hash_info);		if (unlikely(!pc))			return -ENOMEM;		d = to_defact(pc);		ret = alloc_defdata(d, datalen, defdata);		if (ret < 0) {			kfree(pc);			return ret;		}		ret = ACT_P_CREATED;	} else {		d = to_defact(pc);		if (!ovr) {			tcf_simp_release(d, bind);			return -EEXIST;		}		realloc_defdata(d, datalen, defdata);	}	spin_lock_bh(&d->tcf_lock);	d->tcf_action = parm->action;	spin_unlock_bh(&d->tcf_lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(pc, &simp_hash_info);	return ret;}

static int tcf_simp_init(struct nlattr *nla, struct nlattr *est,			 struct tc_action *a, int ovr, int bind){	struct nlattr *tb[TCA_DEF_MAX + 1];	struct tc_defact *parm;	struct tcf_defact *d;	struct tcf_common *pc;	char *defdata;	int ret = 0, err;	if (nla == NULL)		return -EINVAL;	err = nla_parse_nested(tb, TCA_DEF_MAX, nla, simple_policy);	if (err < 0)		return err;	if (tb[TCA_DEF_PARMS] == NULL)		return -EINVAL;	if (tb[TCA_DEF_DATA] == NULL)		return -EINVAL;	parm = nla_data(tb[TCA_DEF_PARMS]);	defdata = nla_data(tb[TCA_DEF_DATA]);	pc = tcf_hash_check(parm->index, a, bind, &simp_hash_info);	if (!pc) {		pc = tcf_hash_create(parm->index, est, a, sizeof(*d), bind,				     &simp_idx_gen, &simp_hash_info);		if (unlikely(!pc))			return -ENOMEM;		d = to_defact(pc);		ret = alloc_defdata(d, defdata);		if (ret < 0) {			kfree(pc);			return ret;		}		d->tcf_action = parm->action;		ret = ACT_P_CREATED;	} else {		d = to_defact(pc);		if (!ovr) {			tcf_simp_release(d, bind);			return -EEXIST;		}		reset_policy(d, defdata, parm);	}	if (ret == ACT_P_CREATED)		tcf_hash_insert(pc, &simp_hash_info);	return ret;}

static int tcf_gact_init(struct rtattr *rta, struct rtattr *est,                         struct tc_action *a, int ovr, int bind){	struct rtattr *tb[TCA_GACT_MAX];	struct tc_gact *parm;	struct tcf_gact *p;	int ret = 0;	if (rta == NULL || rtattr_parse_nested(tb, TCA_GACT_MAX, rta) < 0)		return -EINVAL;	if (tb[TCA_GACT_PARMS - 1] == NULL ||	    RTA_PAYLOAD(tb[TCA_GACT_PARMS - 1]) < sizeof(*parm))		return -EINVAL;	parm = RTA_DATA(tb[TCA_GACT_PARMS - 1]);	if (tb[TCA_GACT_PROB-1] != NULL)#ifdef CONFIG_GACT_PROB		if (RTA_PAYLOAD(tb[TCA_GACT_PROB-1]) < sizeof(struct tc_gact_p))			return -EINVAL;#else		return -EOPNOTSUPP;#endif	p = tcf_hash_check(parm->index, a, ovr, bind);	if (p == NULL) {		p = tcf_hash_create(parm->index, est, a, sizeof(*p), ovr, bind);		if (p == NULL)			return -ENOMEM;		ret = ACT_P_CREATED;	} else {		if (!ovr) {			tcf_hash_release(p, bind);			return -EEXIST;		}	}	spin_lock_bh(&p->lock);	p->action = parm->action;#ifdef CONFIG_GACT_PROB	if (tb[TCA_GACT_PROB-1] != NULL) {		struct tc_gact_p *p_parm = RTA_DATA(tb[TCA_GACT_PROB-1]);		p->paction = p_parm->paction;		p->pval    = p_parm->pval;		p->ptype   = p_parm->ptype;	}#endif	spin_unlock_bh(&p->lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(p);	return ret;}

static int tcf_connmark_init(struct net *net, struct nlattr *nla,			     struct nlattr *est, struct tc_action **a,			     int ovr, int bind){	struct tc_action_net *tn = net_generic(net, connmark_net_id);	struct nlattr *tb[TCA_CONNMARK_MAX + 1];	struct tcf_connmark_info *ci;	struct tc_connmark *parm;	int ret = 0;	if (!nla)		return -EINVAL;	ret = nla_parse_nested(tb, TCA_CONNMARK_MAX, nla, connmark_policy,			       NULL);	if (ret < 0)		return ret;	if (!tb[TCA_CONNMARK_PARMS])		return -EINVAL;	parm = nla_data(tb[TCA_CONNMARK_PARMS]);	if (!tcf_hash_check(tn, parm->index, a, bind)) {		ret = tcf_hash_create(tn, parm->index, est, a,				      &act_connmark_ops, bind, false);		if (ret)			return ret;		ci = to_connmark(*a);		ci->tcf_action = parm->action;		ci->net = net;		ci->zone = parm->zone;		tcf_hash_insert(tn, *a);		ret = ACT_P_CREATED;	} else {		ci = to_connmark(*a);		if (bind)			return 0;		tcf_hash_release(*a, bind);		if (!ovr)			return -EEXIST;		/* replacing action and zone */		ci->tcf_action = parm->action;		ci->zone = parm->zone;	}	return ret;}

static int tcf_nat_init(struct nlattr *nla, struct nlattr *est,			struct tc_action *a, int ovr, int bind){	struct nlattr *tb[TCA_NAT_MAX + 1];	struct tc_nat *parm;	int ret = 0, err;	struct tcf_nat *p;	struct tcf_common *pc;	if (nla == NULL)		return -EINVAL;	err = nla_parse_nested(tb, TCA_NAT_MAX, nla, nat_policy);	if (err < 0)		return err;	if (tb[TCA_NAT_PARMS] == NULL)		return -EINVAL;	parm = nla_data(tb[TCA_NAT_PARMS]);	pc = tcf_hash_check(parm->index, a, bind, &nat_hash_info);	if (!pc) {		pc = tcf_hash_create(parm->index, est, a, sizeof(*p), bind,				     &nat_idx_gen, &nat_hash_info);		if (IS_ERR(pc))		    return PTR_ERR(pc);		p = to_tcf_nat(pc);		ret = ACT_P_CREATED;	} else {		p = to_tcf_nat(pc);		if (!ovr) {			tcf_hash_release(pc, bind, &nat_hash_info);			return -EEXIST;		}	}	spin_lock_bh(&p->tcf_lock);	p->old_addr = parm->old_addr;	p->new_addr = parm->new_addr;	p->mask = parm->mask;	p->flags = parm->flags;	p->tcf_action = parm->action;	spin_unlock_bh(&p->tcf_lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(pc, &nat_hash_info);	return ret;}

static int tcf_nat_init(struct net *net, struct nlattr *nla, struct nlattr *est,			struct tc_action **a, int ovr, int bind){	struct tc_action_net *tn = net_generic(net, nat_net_id);	struct nlattr *tb[TCA_NAT_MAX + 1];	struct tc_nat *parm;	int ret = 0, err;	struct tcf_nat *p;	if (nla == NULL)		return -EINVAL;	err = nla_parse_nested(tb, TCA_NAT_MAX, nla, nat_policy);	if (err < 0)		return err;	if (tb[TCA_NAT_PARMS] == NULL)		return -EINVAL;	parm = nla_data(tb[TCA_NAT_PARMS]);	if (!tcf_hash_check(tn, parm->index, a, bind)) {		ret = tcf_hash_create(tn, parm->index, est, a,				      &act_nat_ops, bind, false);		if (ret)			return ret;		ret = ACT_P_CREATED;	} else {		if (bind)			return 0;		tcf_hash_release(*a, bind);		if (!ovr)			return -EEXIST;	}	p = to_tcf_nat(*a);	spin_lock_bh(&p->tcf_lock);	p->old_addr = parm->old_addr;	p->new_addr = parm->new_addr;	p->mask = parm->mask;	p->flags = parm->flags;	p->tcf_action = parm->action;	spin_unlock_bh(&p->tcf_lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(tn, *a);	return ret;}

static int tcf_nat_init(struct rtattr *rta, struct rtattr *est,			struct tc_action *a, int ovr, int bind){	struct rtattr *tb[TCA_NAT_MAX];	struct tc_nat *parm;	int ret = 0;	struct tcf_nat *p;	struct tcf_common *pc;	if (rta == NULL || rtattr_parse_nested(tb, TCA_NAT_MAX, rta) < 0)		return -EINVAL;	if (tb[TCA_NAT_PARMS - 1] == NULL ||	    RTA_PAYLOAD(tb[TCA_NAT_PARMS - 1]) < sizeof(*parm))		return -EINVAL;	parm = RTA_DATA(tb[TCA_NAT_PARMS - 1]);	pc = tcf_hash_check(parm->index, a, bind, &nat_hash_info);	if (!pc) {		pc = tcf_hash_create(parm->index, est, a, sizeof(*p), bind,				     &nat_idx_gen, &nat_hash_info);		if (unlikely(!pc))			return -ENOMEM;		p = to_tcf_nat(pc);		ret = ACT_P_CREATED;	} else {		p = to_tcf_nat(pc);		if (!ovr) {			tcf_hash_release(pc, bind, &nat_hash_info);			return -EEXIST;		}	}	spin_lock_bh(&p->tcf_lock);	p->old_addr = parm->old_addr;	p->new_addr = parm->new_addr;	p->mask = parm->mask;	p->flags = parm->flags;	p->tcf_action = parm->action;	spin_unlock_bh(&p->tcf_lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(pc, &nat_hash_info);	return ret;}

static int tcf_csum_init(struct net *net, struct nlattr *nla,			 struct nlattr *est, struct tc_action *a, int ovr,			 int bind){	struct tc_action_net *tn = net_generic(net, csum_net_id);	struct nlattr *tb[TCA_CSUM_MAX + 1];	struct tc_csum *parm;	struct tcf_csum *p;	int ret = 0, err;	if (nla == NULL)		return -EINVAL;	err = nla_parse_nested(tb, TCA_CSUM_MAX, nla, csum_policy);	if (err < 0)		return err;	if (tb[TCA_CSUM_PARMS] == NULL)		return -EINVAL;	parm = nla_data(tb[TCA_CSUM_PARMS]);	if (!tcf_hash_check(tn, parm->index, a, bind)) {		ret = tcf_hash_create(tn, parm->index, est, a,				      sizeof(*p), bind, false);		if (ret)			return ret;		ret = ACT_P_CREATED;	} else {		if (bind)/* dont override defaults */			return 0;		tcf_hash_release(a, bind);		if (!ovr)			return -EEXIST;	}	p = to_tcf_csum(a);	spin_lock_bh(&p->tcf_lock);	p->tcf_action = parm->action;	p->update_flags = parm->update_flags;	spin_unlock_bh(&p->tcf_lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(tn, a);	return ret;}

static int tcf_csum_init(struct net *n, struct nlattr *nla, struct nlattr *est,			 struct tc_action *a, int ovr, int bind){	struct nlattr *tb[TCA_CSUM_MAX + 1];	struct tc_csum *parm;	struct tcf_common *pc;	struct tcf_csum *p;	int ret = 0, err;	if (nla == NULL)		return -EINVAL;	err = nla_parse_nested(tb, TCA_CSUM_MAX, nla, csum_policy);	if (err < 0)		return err;	if (tb[TCA_CSUM_PARMS] == NULL)		return -EINVAL;	parm = nla_data(tb[TCA_CSUM_PARMS]);	pc = tcf_hash_check(parm->index, a, bind);	if (!pc) {		pc = tcf_hash_create(parm->index, est, a, sizeof(*p), bind);		if (IS_ERR(pc))			return PTR_ERR(pc);		ret = ACT_P_CREATED;	} else {		if (bind)/* dont override defaults */			return 0;		tcf_hash_release(pc, bind, a->ops->hinfo);		if (!ovr)			return -EEXIST;	}	p = to_tcf_csum(pc);	spin_lock_bh(&p->tcf_lock);	p->tcf_action = parm->action;	p->update_flags = parm->update_flags;	spin_unlock_bh(&p->tcf_lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(pc, a->ops->hinfo);	return ret;}

static int tcf_pedit_init(struct rtattr *rta, struct rtattr *est,			  struct tc_action *a, int ovr, int bind){	struct rtattr *tb[TCA_PEDIT_MAX];	struct tc_pedit *parm;	int ret = 0;	struct tcf_pedit *p;	struct tcf_common *pc;	struct tc_pedit_key *keys = NULL;	int ksize;	if (rta == NULL || rtattr_parse_nested(tb, TCA_PEDIT_MAX, rta) < 0)		return -EINVAL;	if (tb[TCA_PEDIT_PARMS - 1] == NULL ||	    RTA_PAYLOAD(tb[TCA_PEDIT_PARMS-1]) < sizeof(*parm))		return -EINVAL;	parm = RTA_DATA(tb[TCA_PEDIT_PARMS-1]);	ksize = parm->nkeys * sizeof(struct tc_pedit_key);	if (RTA_PAYLOAD(tb[TCA_PEDIT_PARMS-1]) < sizeof(*parm) + ksize)		return -EINVAL;	pc = tcf_hash_check(parm->index, a, bind, &pedit_hash_info);	if (!pc) {		if (!parm->nkeys)			return -EINVAL;		pc = tcf_hash_create(parm->index, est, a, sizeof(*p), bind,				     &pedit_idx_gen, &pedit_hash_info);		if (unlikely(!pc))			return -ENOMEM;		p = to_pedit(pc);		keys = kmalloc(ksize, GFP_KERNEL);		if (keys == NULL) {			kfree(pc);			return -ENOMEM;		}		ret = ACT_P_CREATED;	} else {		p = to_pedit(pc);		if (!ovr) {			tcf_hash_release(pc, bind, &pedit_hash_info);			return -EEXIST;		}		if (p->tcfp_nkeys && p->tcfp_nkeys != parm->nkeys) {			keys = kmalloc(ksize, GFP_KERNEL);			if (keys == NULL)				return -ENOMEM;		}	}	spin_lock_bh(&p->tcf_lock);	p->tcfp_flags = parm->flags;	p->tcf_action = parm->action;	if (keys) {		kfree(p->tcfp_keys);		p->tcfp_keys = keys;		p->tcfp_nkeys = parm->nkeys;	}	memcpy(p->tcfp_keys, parm->keys, ksize);	spin_unlock_bh(&p->tcf_lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(pc, &pedit_hash_info);	return ret;}

static int tcf_pedit_init(struct net *net, struct nlattr *nla,			  struct nlattr *est, struct tc_action *a,			  int ovr, int bind){	struct nlattr *tb[TCA_PEDIT_MAX + 1];	struct tc_pedit *parm;	int ret = 0, err;	struct tcf_pedit *p;	struct tcf_common *pc;	struct tc_pedit_key *keys = NULL;	int ksize;	if (nla == NULL)		return -EINVAL;	err = nla_parse_nested(tb, TCA_PEDIT_MAX, nla, pedit_policy);	if (err < 0)		return err;	if (tb[TCA_PEDIT_PARMS] == NULL)		return -EINVAL;	parm = nla_data(tb[TCA_PEDIT_PARMS]);	ksize = parm->nkeys * sizeof(struct tc_pedit_key);	if (nla_len(tb[TCA_PEDIT_PARMS]) < sizeof(*parm) + ksize)		return -EINVAL;	pc = tcf_hash_check(parm->index, a, bind, &pedit_hash_info);	if (!pc) {		if (!parm->nkeys)			return -EINVAL;		pc = tcf_hash_create(parm->index, est, a, sizeof(*p), bind,				     &pedit_idx_gen, &pedit_hash_info);		if (IS_ERR(pc))			return PTR_ERR(pc);		p = to_pedit(pc);		keys = kmalloc(ksize, GFP_KERNEL);		if (keys == NULL) {			if (est)				gen_kill_estimator(&pc->tcfc_bstats,						   &pc->tcfc_rate_est);			kfree_rcu(pc, tcfc_rcu);			return -ENOMEM;		}		ret = ACT_P_CREATED;	} else {		if (bind)			return 0;		tcf_hash_release(pc, bind, &pedit_hash_info);		if (!ovr)			return -EEXIST;		p = to_pedit(pc);		if (p->tcfp_nkeys && p->tcfp_nkeys != parm->nkeys) {			keys = kmalloc(ksize, GFP_KERNEL);			if (keys == NULL)				return -ENOMEM;		}	}	spin_lock_bh(&p->tcf_lock);	p->tcfp_flags = parm->flags;	p->tcf_action = parm->action;	if (keys) {		kfree(p->tcfp_keys);		p->tcfp_keys = keys;		p->tcfp_nkeys = parm->nkeys;	}	memcpy(p->tcfp_keys, parm->keys, ksize);	spin_unlock_bh(&p->tcf_lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(pc, &pedit_hash_info);	return ret;}

static int tcf_skbedit_init(struct nlattr *nla, struct nlattr *est,			 struct tc_action *a, int ovr, int bind){	struct nlattr *tb[TCA_SKBEDIT_MAX + 1];	struct tc_skbedit *parm;	struct tcf_skbedit *d;	struct tcf_common *pc;	u32 flags = 0, *priority = NULL, *mark = NULL;	u16 *queue_mapping = NULL;	int ret = 0, err;	if (nla == NULL)		return -EINVAL;	err = nla_parse_nested(tb, TCA_SKBEDIT_MAX, nla, skbedit_policy);	if (err < 0)		return err;	if (tb[TCA_SKBEDIT_PARMS] == NULL)		return -EINVAL;	if (tb[TCA_SKBEDIT_PRIORITY] != NULL) {		flags |= SKBEDIT_F_PRIORITY;		priority = nla_data(tb[TCA_SKBEDIT_PRIORITY]);	}	if (tb[TCA_SKBEDIT_QUEUE_MAPPING] != NULL) {		flags |= SKBEDIT_F_QUEUE_MAPPING;		queue_mapping = nla_data(tb[TCA_SKBEDIT_QUEUE_MAPPING]);	}	if (tb[TCA_SKBEDIT_MARK] != NULL) {		flags |= SKBEDIT_F_MARK;		mark = nla_data(tb[TCA_SKBEDIT_MARK]);	}	if (!flags)		return -EINVAL;	parm = nla_data(tb[TCA_SKBEDIT_PARMS]);	pc = tcf_hash_check(parm->index, a, bind, &skbedit_hash_info);	if (!pc) {		pc = tcf_hash_create(parm->index, est, a, sizeof(*d), bind,				     &skbedit_idx_gen, &skbedit_hash_info);		if (IS_ERR(pc))			return PTR_ERR(pc);		d = to_skbedit(pc);		ret = ACT_P_CREATED;	} else {		d = to_skbedit(pc);		if (!ovr) {			tcf_hash_release(pc, bind, &skbedit_hash_info);			return -EEXIST;		}	}	spin_lock_bh(&d->tcf_lock);	d->flags = flags;	if (flags & SKBEDIT_F_PRIORITY)		d->priority = *priority;	if (flags & SKBEDIT_F_QUEUE_MAPPING)		d->queue_mapping = *queue_mapping;	if (flags & SKBEDIT_F_MARK)		d->mark = *mark;	d->tcf_action = parm->action;	spin_unlock_bh(&d->tcf_lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(pc, &skbedit_hash_info);	return ret;}

static int tcf_pedit_init(struct net *net, struct nlattr *nla,			  struct nlattr *est, struct tc_action *a,			  int ovr, int bind){	struct tc_action_net *tn = net_generic(net, pedit_net_id);	struct nlattr *tb[TCA_PEDIT_MAX + 1];	struct tc_pedit *parm;	int ret = 0, err;	struct tcf_pedit *p;	struct tc_pedit_key *keys = NULL;	int ksize;	if (nla == NULL)		return -EINVAL;	err = nla_parse_nested(tb, TCA_PEDIT_MAX, nla, pedit_policy);	if (err < 0)		return err;	if (tb[TCA_PEDIT_PARMS] == NULL)		return -EINVAL;	parm = nla_data(tb[TCA_PEDIT_PARMS]);	ksize = parm->nkeys * sizeof(struct tc_pedit_key);	if (nla_len(tb[TCA_PEDIT_PARMS]) < sizeof(*parm) + ksize)		return -EINVAL;	if (!tcf_hash_check(tn, parm->index, a, bind)) {		if (!parm->nkeys)			return -EINVAL;		ret = tcf_hash_create(tn, parm->index, est, a,				      sizeof(*p), bind, false);		if (ret)			return ret;		p = to_pedit(a);		keys = kmalloc(ksize, GFP_KERNEL);		if (keys == NULL) {			tcf_hash_cleanup(a, est);			return -ENOMEM;		}		ret = ACT_P_CREATED;	} else {		if (bind)			return 0;		tcf_hash_release(a, bind);		if (!ovr)			return -EEXIST;		p = to_pedit(a);		if (p->tcfp_nkeys && p->tcfp_nkeys != parm->nkeys) {			keys = kmalloc(ksize, GFP_KERNEL);			if (keys == NULL)				return -ENOMEM;		}	}	spin_lock_bh(&p->tcf_lock);	p->tcfp_flags = parm->flags;	p->tcf_action = parm->action;	if (keys) {		kfree(p->tcfp_keys);		p->tcfp_keys = keys;		p->tcfp_nkeys = parm->nkeys;	}	memcpy(p->tcfp_keys, parm->keys, ksize);	spin_unlock_bh(&p->tcf_lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(tn, a);	return ret;}

static int tcf_mirred_init(struct rtattr *rta, struct rtattr *est,			   struct tc_action *a, int ovr, int bind){	struct rtattr *tb[TCA_MIRRED_MAX];	struct tc_mirred *parm;	struct tcf_mirred *m;	struct tcf_common *pc;	struct net_device *dev = NULL;	int ret = 0;	int ok_push = 0;	if (rta == NULL || rtattr_parse_nested(tb, TCA_MIRRED_MAX, rta) < 0)		return -EINVAL;	if (tb[TCA_MIRRED_PARMS-1] == NULL ||	    RTA_PAYLOAD(tb[TCA_MIRRED_PARMS-1]) < sizeof(*parm))		return -EINVAL;	parm = RTA_DATA(tb[TCA_MIRRED_PARMS-1]);	if (parm->ifindex) {		dev = __dev_get_by_index(parm->ifindex);		if (dev == NULL)			return -ENODEV;		switch (dev->type) {			case ARPHRD_TUNNEL:			case ARPHRD_TUNNEL6:			case ARPHRD_SIT:			case ARPHRD_IPGRE:			case ARPHRD_VOID:			case ARPHRD_NONE:				ok_push = 0;				break;			default:				ok_push = 1;				break;		}	}	pc = tcf_hash_check(parm->index, a, bind, &mirred_hash_info);	if (!pc) {		if (!parm->ifindex)			return -EINVAL;		pc = tcf_hash_create(parm->index, est, a, sizeof(*m), bind,				     &mirred_idx_gen, &mirred_hash_info);		if (unlikely(!pc))			return -ENOMEM;		ret = ACT_P_CREATED;	} else {		if (!ovr) {			tcf_mirred_release(to_mirred(pc), bind);			return -EEXIST;		}	}	m = to_mirred(pc);	spin_lock_bh(&m->tcf_lock);	m->tcf_action = parm->action;	m->tcfm_eaction = parm->eaction;	if (parm->ifindex) {		m->tcfm_ifindex = parm->ifindex;		if (ret != ACT_P_CREATED)			dev_put(m->tcfm_dev);		m->tcfm_dev = dev;		dev_hold(dev);		m->tcfm_ok_push = ok_push;	}	spin_unlock_bh(&m->tcf_lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(pc, &mirred_hash_info);	return ret;}

static int tcf_vlan_init(struct net *net, struct nlattr *nla,			 struct nlattr *est, struct tc_action *a,			 int ovr, int bind){	struct tc_action_net *tn = net_generic(net, vlan_net_id);	struct nlattr *tb[TCA_VLAN_MAX + 1];	struct tc_vlan *parm;	struct tcf_vlan *v;	int action;	__be16 push_vid = 0;	__be16 push_proto = 0;	int ret = 0, exists = 0;	int err;	if (!nla)		return -EINVAL;	err = nla_parse_nested(tb, TCA_VLAN_MAX, nla, vlan_policy);	if (err < 0)		return err;	if (!tb[TCA_VLAN_PARMS])		return -EINVAL;	parm = nla_data(tb[TCA_VLAN_PARMS]);	exists = tcf_hash_check(tn, parm->index, a, bind);	if (exists && bind)		return 0;	switch (parm->v_action) {	case TCA_VLAN_ACT_POP:		break;	case TCA_VLAN_ACT_PUSH:		if (!tb[TCA_VLAN_PUSH_VLAN_ID]) {			if (exists)				tcf_hash_release(a, bind);			return -EINVAL;		}		push_vid = nla_get_u16(tb[TCA_VLAN_PUSH_VLAN_ID]);		if (push_vid >= VLAN_VID_MASK) {			if (exists)				tcf_hash_release(a, bind);			return -ERANGE;		}		if (tb[TCA_VLAN_PUSH_VLAN_PROTOCOL]) {			push_proto = nla_get_be16(tb[TCA_VLAN_PUSH_VLAN_PROTOCOL]);			switch (push_proto) {			case htons(ETH_P_8021Q):			case htons(ETH_P_8021AD):				break;			default:				return -EPROTONOSUPPORT;			}		} else {			push_proto = htons(ETH_P_8021Q);		}		break;	default:		if (exists)			tcf_hash_release(a, bind);		return -EINVAL;	}	action = parm->v_action;	if (!exists) {		ret = tcf_hash_create(tn, parm->index, est, a,				      sizeof(*v), bind, false);		if (ret)			return ret;		ret = ACT_P_CREATED;	} else {		tcf_hash_release(a, bind);		if (!ovr)			return -EEXIST;	}	v = to_vlan(a);	spin_lock_bh(&v->tcf_lock);	v->tcfv_action = action;	v->tcfv_push_vid = push_vid;	v->tcfv_push_proto = push_proto;	v->tcf_action = parm->action;	spin_unlock_bh(&v->tcf_lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(tn, a);	return ret;}

static int tcf_ipt_init(struct rtattr *rta, struct rtattr *est,			struct tc_action *a, int ovr, int bind){	struct rtattr *tb[TCA_IPT_MAX];	struct tcf_ipt *ipt;	struct tcf_common *pc;	struct ipt_entry_target *td, *t;	char *tname;	int ret = 0, err;	u32 hook = 0;	u32 index = 0;	if (rta == NULL || rtattr_parse_nested(tb, TCA_IPT_MAX, rta) < 0)		return -EINVAL;	if (tb[TCA_IPT_HOOK-1] == NULL ||	    RTA_PAYLOAD(tb[TCA_IPT_HOOK-1]) < sizeof(u32))		return -EINVAL;	if (tb[TCA_IPT_TARG-1] == NULL ||	    RTA_PAYLOAD(tb[TCA_IPT_TARG-1]) < sizeof(*t))		return -EINVAL;	td = (struct ipt_entry_target *)RTA_DATA(tb[TCA_IPT_TARG-1]);	if (RTA_PAYLOAD(tb[TCA_IPT_TARG-1]) < td->u.target_size)		return -EINVAL;	if (tb[TCA_IPT_INDEX-1] != NULL &&	    RTA_PAYLOAD(tb[TCA_IPT_INDEX-1]) >= sizeof(u32))		index = *(u32 *)RTA_DATA(tb[TCA_IPT_INDEX-1]);	pc = tcf_hash_check(index, a, bind, &ipt_hash_info);	if (!pc) {		pc = tcf_hash_create(index, est, a, sizeof(*ipt), bind,				     &ipt_idx_gen, &ipt_hash_info);		if (unlikely(!pc))			return -ENOMEM;		ret = ACT_P_CREATED;	} else {		if (!ovr) {			tcf_ipt_release(to_ipt(pc), bind);			return -EEXIST;		}	}	ipt = to_ipt(pc);	hook = *(u32 *)RTA_DATA(tb[TCA_IPT_HOOK-1]);	err = -ENOMEM;	tname = kmalloc(IFNAMSIZ, GFP_KERNEL);	if (unlikely(!tname))		goto err1;	if (tb[TCA_IPT_TABLE - 1] == NULL ||	    rtattr_strlcpy(tname, tb[TCA_IPT_TABLE-1], IFNAMSIZ) >= IFNAMSIZ)		strcpy(tname, "mangle");	t = kmemdup(td, td->u.target_size, GFP_KERNEL);	if (unlikely(!t))		goto err2;	if ((err = ipt_init_target(t, tname, hook)) < 0)		goto err3;	spin_lock_bh(&ipt->tcf_lock);	if (ret != ACT_P_CREATED) {		ipt_destroy_target(ipt->tcfi_t);		kfree(ipt->tcfi_tname);		kfree(ipt->tcfi_t);	}	ipt->tcfi_tname = tname;	ipt->tcfi_t     = t;	ipt->tcfi_hook  = hook;	spin_unlock_bh(&ipt->tcf_lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(pc, &ipt_hash_info);	return ret;err3:	kfree(t);err2:	kfree(tname);err1:	kfree(pc);	return err;}

static inttcf_ipt_init(struct rtattr *rta, struct rtattr *est, struct tc_action *a,             int ovr, int bind){	struct rtattr *tb[TCA_IPT_MAX];	struct tcf_ipt *p;	struct ipt_entry_target *td, *t;	char *tname;	int ret = 0, err;	u32 hook = 0;	u32 index = 0;	if (rta == NULL || rtattr_parse_nested(tb, TCA_IPT_MAX, rta) < 0)		return -EINVAL;	if (tb[TCA_IPT_HOOK-1] == NULL ||	    RTA_PAYLOAD(tb[TCA_IPT_HOOK-1]) < sizeof(u32))		return -EINVAL;	if (tb[TCA_IPT_TARG-1] == NULL ||	    RTA_PAYLOAD(tb[TCA_IPT_TARG-1]) < sizeof(*t))		return -EINVAL;	td = (struct ipt_entry_target *)RTA_DATA(tb[TCA_IPT_TARG-1]);	if (RTA_PAYLOAD(tb[TCA_IPT_TARG-1]) < td->u.target_size)		return -EINVAL;	if (tb[TCA_IPT_INDEX-1] != NULL &&	    RTA_PAYLOAD(tb[TCA_IPT_INDEX-1]) >= sizeof(u32))		index = *(u32 *)RTA_DATA(tb[TCA_IPT_INDEX-1]);	p = tcf_hash_check(index, a, ovr, bind);	if (p == NULL) {		p = tcf_hash_create(index, est, a, sizeof(*p), ovr, bind);		if (p == NULL)			return -ENOMEM;		ret = ACT_P_CREATED;	} else {		if (!ovr) {			tcf_ipt_release(p, bind);			return -EEXIST;		}	}	hook = *(u32 *)RTA_DATA(tb[TCA_IPT_HOOK-1]);	err = -ENOMEM;	tname = kmalloc(IFNAMSIZ, GFP_KERNEL);	if (tname == NULL)		goto err1;	if (tb[TCA_IPT_TABLE - 1] == NULL ||	    rtattr_strlcpy(tname, tb[TCA_IPT_TABLE-1], IFNAMSIZ) >= IFNAMSIZ)		strcpy(tname, "mangle");	t = kmalloc(td->u.target_size, GFP_KERNEL);	if (t == NULL)		goto err2;	memcpy(t, td, td->u.target_size);	if ((err = ipt_init_target(t, tname, hook)) < 0)		goto err3;	spin_lock_bh(&p->lock);	if (ret != ACT_P_CREATED) {		ipt_destroy_target(p->t);		kfree(p->tname);		kfree(p->t);	}	p->tname = tname;	p->t     = t;	p->hook  = hook;	spin_unlock_bh(&p->lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(p);	return ret;err3:	kfree(t);err2:	kfree(tname);err1:	kfree(p);	return err;}

static int tcf_gact_init(struct net *net, struct nlattr *nla,			 struct nlattr *est, struct tc_action *a,			 int ovr, int bind){	struct tc_action_net *tn = net_generic(net, gact_net_id);	struct nlattr *tb[TCA_GACT_MAX + 1];	struct tc_gact *parm;	struct tcf_gact *gact;	int ret = 0;	int err;#ifdef CONFIG_GACT_PROB	struct tc_gact_p *p_parm = NULL;#endif	if (nla == NULL)		return -EINVAL;	err = nla_parse_nested(tb, TCA_GACT_MAX, nla, gact_policy);	if (err < 0)		return err;	if (tb[TCA_GACT_PARMS] == NULL)		return -EINVAL;	parm = nla_data(tb[TCA_GACT_PARMS]);#ifndef CONFIG_GACT_PROB	if (tb[TCA_GACT_PROB] != NULL)		return -EOPNOTSUPP;#else	if (tb[TCA_GACT_PROB]) {		p_parm = nla_data(tb[TCA_GACT_PROB]);		if (p_parm->ptype >= MAX_RAND)			return -EINVAL;	}#endif	if (!tcf_hash_check(tn, parm->index, a, bind)) {		ret = tcf_hash_create(tn, parm->index, est, a,				      sizeof(*gact), bind, true);		if (ret)			return ret;		ret = ACT_P_CREATED;	} else {		if (bind)/* dont override defaults */			return 0;		tcf_hash_release(a, bind);		if (!ovr)			return -EEXIST;	}	gact = to_gact(a);	ASSERT_RTNL();	gact->tcf_action = parm->action;#ifdef CONFIG_GACT_PROB	if (p_parm) {		gact->tcfg_paction = p_parm->paction;		gact->tcfg_pval    = max_t(u16, 1, p_parm->pval);		/* Make sure tcfg_pval is written before tcfg_ptype		 * coupled with smp_rmb() in gact_net_rand() & gact_determ()		 */		smp_wmb();		gact->tcfg_ptype   = p_parm->ptype;	}#endif	if (ret == ACT_P_CREATED)		tcf_hash_insert(tn, a);	return ret;}

static int tcf_simp_init(struct net *net, struct nlattr *nla,			 struct nlattr *est, struct tc_action **a,			 int ovr, int bind){	struct tc_action_net *tn = net_generic(net, simp_net_id);	struct nlattr *tb[TCA_DEF_MAX + 1];	struct tc_defact *parm;	struct tcf_defact *d;	bool exists = false;	int ret = 0, err;	char *defdata;	if (nla == NULL)		return -EINVAL;	err = nla_parse_nested(tb, TCA_DEF_MAX, nla, simple_policy, NULL);	if (err < 0)		return err;	if (tb[TCA_DEF_PARMS] == NULL)		return -EINVAL;	parm = nla_data(tb[TCA_DEF_PARMS]);	exists = tcf_hash_check(tn, parm->index, a, bind);	if (exists && bind)		return 0;	if (tb[TCA_DEF_DATA] == NULL) {		if (exists)			tcf_hash_release(*a, bind);		return -EINVAL;	}	defdata = nla_data(tb[TCA_DEF_DATA]);	if (!exists) {		ret = tcf_hash_create(tn, parm->index, est, a,				      &act_simp_ops, bind, false);		if (ret)			return ret;		d = to_defact(*a);		ret = alloc_defdata(d, defdata);		if (ret < 0) {			tcf_hash_cleanup(*a, est);			return ret;		}		d->tcf_action = parm->action;		ret = ACT_P_CREATED;	} else {		d = to_defact(*a);		tcf_hash_release(*a, bind);		if (!ovr)			return -EEXIST;		reset_policy(d, defdata, parm);	}	if (ret == ACT_P_CREATED)		tcf_hash_insert(tn, *a);	return ret;}

static int tcf_bpf_init(struct net *net, struct nlattr *nla,			struct nlattr *est, struct tc_action **act,			int replace, int bind){	struct tc_action_net *tn = net_generic(net, bpf_net_id);	struct nlattr *tb[TCA_ACT_BPF_MAX + 1];	struct tcf_bpf_cfg cfg, old;	struct tc_act_bpf *parm;	struct tcf_bpf *prog;	bool is_bpf, is_ebpf;	int ret, res = 0;	if (!nla)		return -EINVAL;	ret = nla_parse_nested(tb, TCA_ACT_BPF_MAX, nla, act_bpf_policy);	if (ret < 0)		return ret;	if (!tb[TCA_ACT_BPF_PARMS])		return -EINVAL;	parm = nla_data(tb[TCA_ACT_BPF_PARMS]);	if (!tcf_hash_check(tn, parm->index, act, bind)) {		ret = tcf_hash_create(tn, parm->index, est, act,				      &act_bpf_ops, bind, true);		if (ret < 0)			return ret;		res = ACT_P_CREATED;	} else {		/* Don't override defaults. */		if (bind)			return 0;		tcf_hash_release(*act, bind);		if (!replace)			return -EEXIST;	}	is_bpf = tb[TCA_ACT_BPF_OPS_LEN] && tb[TCA_ACT_BPF_OPS];	is_ebpf = tb[TCA_ACT_BPF_FD];	if ((!is_bpf && !is_ebpf) || (is_bpf && is_ebpf)) {		ret = -EINVAL;		goto out;	}	memset(&cfg, 0, sizeof(cfg));	ret = is_bpf ? tcf_bpf_init_from_ops(tb, &cfg) :		       tcf_bpf_init_from_efd(tb, &cfg);	if (ret < 0)		goto out;	prog = to_bpf(*act);	ASSERT_RTNL();	if (res != ACT_P_CREATED)		tcf_bpf_prog_fill_cfg(prog, &old);	prog->bpf_ops = cfg.bpf_ops;	prog->bpf_name = cfg.bpf_name;	if (cfg.bpf_num_ops)		prog->bpf_num_ops = cfg.bpf_num_ops;	if (cfg.bpf_fd)		prog->bpf_fd = cfg.bpf_fd;	prog->tcf_action = parm->action;	rcu_assign_pointer(prog->filter, cfg.filter);	if (res == ACT_P_CREATED) {		tcf_hash_insert(tn, *act);	} else {		/* make sure the program being replaced is no longer executing */		synchronize_rcu();		tcf_bpf_cfg_cleanup(&old);	}	return res;out:	if (res == ACT_P_CREATED)		tcf_hash_cleanup(*act, est);	return ret;}

static int tcf_bpf_init(struct net *net, struct nlattr *nla,			struct nlattr *est, struct tc_action *act,			int replace, int bind){	struct nlattr *tb[TCA_ACT_BPF_MAX + 1];	struct tc_act_bpf *parm;	struct tcf_bpf *prog;	struct tcf_bpf_cfg cfg;	bool is_bpf, is_ebpf;	int ret;	if (!nla)		return -EINVAL;	ret = nla_parse_nested(tb, TCA_ACT_BPF_MAX, nla, act_bpf_policy);	if (ret < 0)		return ret;	is_bpf = tb[TCA_ACT_BPF_OPS_LEN] && tb[TCA_ACT_BPF_OPS];	is_ebpf = tb[TCA_ACT_BPF_FD];	if ((!is_bpf && !is_ebpf) || (is_bpf && is_ebpf) ||	    !tb[TCA_ACT_BPF_PARMS])		return -EINVAL;	parm = nla_data(tb[TCA_ACT_BPF_PARMS]);	memset(&cfg, 0, sizeof(cfg));	ret = is_bpf ? tcf_bpf_init_from_ops(tb, &cfg) :		       tcf_bpf_init_from_efd(tb, &cfg);	if (ret < 0)		return ret;	if (!tcf_hash_check(parm->index, act, bind)) {		ret = tcf_hash_create(parm->index, est, act,				      sizeof(*prog), bind);		if (ret < 0)			goto destroy_fp;		ret = ACT_P_CREATED;	} else {		/* Don't override defaults. */		if (bind)			goto destroy_fp;		tcf_hash_release(act, bind);		if (!replace) {			ret = -EEXIST;			goto destroy_fp;		}	}	prog = to_bpf(act);	spin_lock_bh(&prog->tcf_lock);	prog->bpf_ops = cfg.bpf_ops;	prog->bpf_name = cfg.bpf_name;	if (cfg.bpf_num_ops)		prog->bpf_num_ops = cfg.bpf_num_ops;	if (cfg.bpf_fd)		prog->bpf_fd = cfg.bpf_fd;	prog->tcf_action = parm->action;	prog->filter = cfg.filter;	spin_unlock_bh(&prog->tcf_lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(act);	return ret;destroy_fp:	if (is_ebpf)		bpf_prog_put(cfg.filter);	else		bpf_prog_destroy(cfg.filter);	kfree(cfg.bpf_ops);	kfree(cfg.bpf_name);	return ret;}

static int tcf_ipt_init(struct net *net, struct nlattr *nla, struct nlattr *est,			struct tc_action *a, int ovr, int bind){	struct nlattr *tb[TCA_IPT_MAX + 1];	struct tcf_ipt *ipt;	struct xt_entry_target *td, *t;	char *tname;	int ret = 0, err;	u32 hook = 0;	u32 index = 0;	if (nla == NULL)		return -EINVAL;	err = nla_parse_nested(tb, TCA_IPT_MAX, nla, ipt_policy);	if (err < 0)		return err;	if (tb[TCA_IPT_HOOK] == NULL)		return -EINVAL;	if (tb[TCA_IPT_TARG] == NULL)		return -EINVAL;	td = (struct xt_entry_target *)nla_data(tb[TCA_IPT_TARG]);	if (nla_len(tb[TCA_IPT_TARG]) < td->u.target_size)		return -EINVAL;	if (tb[TCA_IPT_INDEX] != NULL)		index = nla_get_u32(tb[TCA_IPT_INDEX]);	if (!tcf_hash_check(index, a, bind) ) {		ret = tcf_hash_create(index, est, a, sizeof(*ipt), bind);		if (ret)			return ret;		ret = ACT_P_CREATED;	} else {		if (bind)/* dont override defaults */			return 0;		tcf_hash_release(a, bind);		if (!ovr)			return -EEXIST;	}	ipt = to_ipt(a);	hook = nla_get_u32(tb[TCA_IPT_HOOK]);	err = -ENOMEM;	tname = kmalloc(IFNAMSIZ, GFP_KERNEL);	if (unlikely(!tname))		goto err1;	if (tb[TCA_IPT_TABLE] == NULL ||	    nla_strlcpy(tname, tb[TCA_IPT_TABLE], IFNAMSIZ) >= IFNAMSIZ)		strcpy(tname, "mangle");	t = kmemdup(td, td->u.target_size, GFP_KERNEL);	if (unlikely(!t))		goto err2;	err = ipt_init_target(t, tname, hook);	if (err < 0)		goto err3;	spin_lock_bh(&ipt->tcf_lock);	if (ret != ACT_P_CREATED) {		ipt_destroy_target(ipt->tcfi_t);		kfree(ipt->tcfi_tname);		kfree(ipt->tcfi_t);	}	ipt->tcfi_tname = tname;	ipt->tcfi_t     = t;	ipt->tcfi_hook  = hook;	spin_unlock_bh(&ipt->tcf_lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(a);	return ret;err3:	kfree(t);err2:	kfree(tname);err1:	if (ret == ACT_P_CREATED)		tcf_hash_cleanup(a, est);	return err;}

static int tcf_skbedit_init(struct net *net, struct nlattr *nla,			    struct nlattr *est, struct tc_action *a,			    int ovr, int bind){	struct tc_action_net *tn = net_generic(net, skbedit_net_id);	struct nlattr *tb[TCA_SKBEDIT_MAX + 1];	struct tc_skbedit *parm;	struct tcf_skbedit *d;	u32 flags = 0, *priority = NULL, *mark = NULL;	u16 *queue_mapping = NULL;	int ret = 0, err, exists = 0;	if (nla == NULL)		return -EINVAL;	err = nla_parse_nested(tb, TCA_SKBEDIT_MAX, nla, skbedit_policy);	if (err < 0)		return err;	if (tb[TCA_SKBEDIT_PARMS] == NULL)		return -EINVAL;	if (tb[TCA_SKBEDIT_PRIORITY] != NULL) {		flags |= SKBEDIT_F_PRIORITY;		priority = nla_data(tb[TCA_SKBEDIT_PRIORITY]);	}	if (tb[TCA_SKBEDIT_QUEUE_MAPPING] != NULL) {		flags |= SKBEDIT_F_QUEUE_MAPPING;		queue_mapping = nla_data(tb[TCA_SKBEDIT_QUEUE_MAPPING]);	}	if (tb[TCA_SKBEDIT_MARK] != NULL) {		flags |= SKBEDIT_F_MARK;		mark = nla_data(tb[TCA_SKBEDIT_MARK]);	}	parm = nla_data(tb[TCA_SKBEDIT_PARMS]);	exists = tcf_hash_check(tn, parm->index, a, bind);	if (exists && bind)		return 0;	if (!flags) {		tcf_hash_release(a, bind);		return -EINVAL;	}	if (!exists) {		ret = tcf_hash_create(tn, parm->index, est, a,				      sizeof(*d), bind, false);		if (ret)			return ret;		d = to_skbedit(a);		ret = ACT_P_CREATED;	} else {		d = to_skbedit(a);		tcf_hash_release(a, bind);		if (!ovr)			return -EEXIST;	}	spin_lock_bh(&d->tcf_lock);	d->flags = flags;	if (flags & SKBEDIT_F_PRIORITY)		d->priority = *priority;	if (flags & SKBEDIT_F_QUEUE_MAPPING)		d->queue_mapping = *queue_mapping;	if (flags & SKBEDIT_F_MARK)		d->mark = *mark;	d->tcf_action = parm->action;	spin_unlock_bh(&d->tcf_lock);	if (ret == ACT_P_CREATED)		tcf_hash_insert(tn, a);	return ret;}

static int tcf_skbmod_init(struct net *net, struct nlattr *nla,			   struct nlattr *est, struct tc_action **a,			   int ovr, int bind){	struct tc_action_net *tn = net_generic(net, skbmod_net_id);	struct nlattr *tb[TCA_SKBMOD_MAX + 1];	struct tcf_skbmod_params *p, *p_old;	struct tc_skbmod *parm;	struct tcf_skbmod *d;	bool exists = false;	u8 *daddr = NULL;	u8 *saddr = NULL;	u16 eth_type = 0;	u32 lflags = 0;	int ret = 0, err;	if (!nla)		return -EINVAL;	err = nla_parse_nested(tb, TCA_SKBMOD_MAX, nla, skbmod_policy);	if (err < 0)		return err;	if (!tb[TCA_SKBMOD_PARMS])		return -EINVAL;	if (tb[TCA_SKBMOD_DMAC]) {		daddr = nla_data(tb[TCA_SKBMOD_DMAC]);		lflags |= SKBMOD_F_DMAC;	}	if (tb[TCA_SKBMOD_SMAC]) {		saddr = nla_data(tb[TCA_SKBMOD_SMAC]);		lflags |= SKBMOD_F_SMAC;	}	if (tb[TCA_SKBMOD_ETYPE]) {		eth_type = nla_get_u16(tb[TCA_SKBMOD_ETYPE]);		lflags |= SKBMOD_F_ETYPE;	}	parm = nla_data(tb[TCA_SKBMOD_PARMS]);	if (parm->flags & SKBMOD_F_SWAPMAC)		lflags = SKBMOD_F_SWAPMAC;	exists = tcf_hash_check(tn, parm->index, a, bind);	if (exists && bind)		return 0;	if (!lflags)		return -EINVAL;	if (!exists) {		ret = tcf_hash_create(tn, parm->index, est, a,				      &act_skbmod_ops, bind, true);		if (ret)			return ret;		ret = ACT_P_CREATED;	} else {		tcf_hash_release(*a, bind);		if (!ovr)			return -EEXIST;	}	d = to_skbmod(*a);	ASSERT_RTNL();	p = kzalloc(sizeof(struct tcf_skbmod_params), GFP_KERNEL);	if (unlikely(!p)) {		if (ovr)			tcf_hash_release(*a, bind);		return -ENOMEM;	}	p->flags = lflags;	d->tcf_action = parm->action;	p_old = rtnl_dereference(d->skbmod_p);	if (ovr)		spin_lock_bh(&d->tcf_lock);	if (lflags & SKBMOD_F_DMAC)		ether_addr_copy(p->eth_dst, daddr);	if (lflags & SKBMOD_F_SMAC)		ether_addr_copy(p->eth_src, saddr);	if (lflags & SKBMOD_F_ETYPE)		p->eth_type = htons(eth_type);	rcu_assign_pointer(d->skbmod_p, p);	if (ovr)		spin_unlock_bh(&d->tcf_lock);	if (p_old)		kfree_rcu(p_old, rcu);	if (ret == ACT_P_CREATED)		tcf_hash_insert(tn, *a);	return ret;//.........这里部分代码省略.........