xref: /openbmc/linux/net/sched/act_pedit.c (revision c4c3c32d) 
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * net/sched/act_pedit.c	Generic packet editor
4  *
5  * Authors:	Jamal Hadi Salim (2002-4)
6  */
7 
8 #include <linux/types.h>
9 #include <linux/kernel.h>
10 #include <linux/string.h>
11 #include <linux/errno.h>
12 #include <linux/skbuff.h>
13 #include <linux/rtnetlink.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/ip.h>
17 #include <linux/ipv6.h>
18 #include <linux/slab.h>
19 #include <net/ipv6.h>
20 #include <net/netlink.h>
21 #include <net/pkt_sched.h>
22 #include <linux/tc_act/tc_pedit.h>
23 #include <net/tc_act/tc_pedit.h>
24 #include <uapi/linux/tc_act/tc_pedit.h>
25 #include <net/pkt_cls.h>
26 #include <net/tc_wrapper.h>
27 
28 static struct tc_action_ops act_pedit_ops;
29 
30 static const struct nla_policy pedit_policy[TCA_PEDIT_MAX + 1] = {
31 	[TCA_PEDIT_PARMS]	= { .len = sizeof(struct tc_pedit) },
32 	[TCA_PEDIT_PARMS_EX]	= { .len = sizeof(struct tc_pedit) },
33 	[TCA_PEDIT_KEYS_EX]   = { .type = NLA_NESTED },
34 };
35 
36 static const struct nla_policy pedit_key_ex_policy[TCA_PEDIT_KEY_EX_MAX + 1] = {
37 	[TCA_PEDIT_KEY_EX_HTYPE] =
38 		NLA_POLICY_MAX(NLA_U16, TCA_PEDIT_HDR_TYPE_MAX),
39 	[TCA_PEDIT_KEY_EX_CMD] = NLA_POLICY_MAX(NLA_U16, TCA_PEDIT_CMD_MAX),
40 };
41 
42 static struct tcf_pedit_key_ex *tcf_pedit_keys_ex_parse(struct nlattr *nla,
43 							u8 n, struct netlink_ext_ack *extack)
44 {
45 	struct tcf_pedit_key_ex *keys_ex;
46 	struct tcf_pedit_key_ex *k;
47 	const struct nlattr *ka;
48 	int err = -EINVAL;
49 	int rem;
50 
51 	if (!nla)
52 		return NULL;
53 
54 	keys_ex = kcalloc(n, sizeof(*k), GFP_KERNEL);
55 	if (!keys_ex)
56 		return ERR_PTR(-ENOMEM);
57 
58 	k = keys_ex;
59 
60 	nla_for_each_nested(ka, nla, rem) {
61 		struct nlattr *tb[TCA_PEDIT_KEY_EX_MAX + 1];
62 
63 		if (!n) {
64 			NL_SET_ERR_MSG_MOD(extack, "Can't parse more extended keys than requested");
65 			err = -EINVAL;
66 			goto err_out;
67 		}
68 		n--;
69 
70 		if (nla_type(ka) != TCA_PEDIT_KEY_EX) {
71 			NL_SET_ERR_MSG_ATTR(extack, ka, "Unknown attribute, expected extended key");
72 			err = -EINVAL;
73 			goto err_out;
74 		}
75 
76 		err = nla_parse_nested_deprecated(tb, TCA_PEDIT_KEY_EX_MAX,
77 						  ka, pedit_key_ex_policy,
78 						  NULL);
79 		if (err)
80 			goto err_out;
81 
82 		if (NL_REQ_ATTR_CHECK(extack, nla, tb, TCA_PEDIT_KEY_EX_HTYPE)) {
83 			NL_SET_ERR_MSG(extack, "Missing required attribute");
84 			err = -EINVAL;
85 			goto err_out;
86 		}
87 
88 		if (NL_REQ_ATTR_CHECK(extack, nla, tb, TCA_PEDIT_KEY_EX_CMD)) {
89 			NL_SET_ERR_MSG(extack, "Missing required attribute");
90 			err = -EINVAL;
91 			goto err_out;
92 		}
93 
94 		k->htype = nla_get_u16(tb[TCA_PEDIT_KEY_EX_HTYPE]);
95 		k->cmd = nla_get_u16(tb[TCA_PEDIT_KEY_EX_CMD]);
96 
97 		k++;
98 	}
99 
100 	if (n) {
101 		NL_SET_ERR_MSG_MOD(extack, "Not enough extended keys to parse");
102 		err = -EINVAL;
103 		goto err_out;
104 	}
105 
106 	return keys_ex;
107 
108 err_out:
109 	kfree(keys_ex);
110 	return ERR_PTR(err);
111 }
112 
113 static int tcf_pedit_key_ex_dump(struct sk_buff *skb,
114 				 struct tcf_pedit_key_ex *keys_ex, int n)
115 {
116 	struct nlattr *keys_start = nla_nest_start_noflag(skb,
117 							  TCA_PEDIT_KEYS_EX);
118 
119 	if (!keys_start)
120 		goto nla_failure;
121 	for (; n > 0; n--) {
122 		struct nlattr *key_start;
123 
124 		key_start = nla_nest_start_noflag(skb, TCA_PEDIT_KEY_EX);
125 		if (!key_start)
126 			goto nla_failure;
127 
128 		if (nla_put_u16(skb, TCA_PEDIT_KEY_EX_HTYPE, keys_ex->htype) ||
129 		    nla_put_u16(skb, TCA_PEDIT_KEY_EX_CMD, keys_ex->cmd))
130 			goto nla_failure;
131 
132 		nla_nest_end(skb, key_start);
133 
134 		keys_ex++;
135 	}
136 
137 	nla_nest_end(skb, keys_start);
138 
139 	return 0;
140 nla_failure:
141 	nla_nest_cancel(skb, keys_start);
142 	return -EINVAL;
143 }
144 
145 static void tcf_pedit_cleanup_rcu(struct rcu_head *head)
146 {
147 	struct tcf_pedit_parms *parms =
148 		container_of(head, struct tcf_pedit_parms, rcu);
149 
150 	kfree(parms->tcfp_keys_ex);
151 	kfree(parms->tcfp_keys);
152 
153 	kfree(parms);
154 }
155 
156 static int tcf_pedit_init(struct net *net, struct nlattr *nla,
157 			  struct nlattr *est, struct tc_action **a,
158 			  struct tcf_proto *tp, u32 flags,
159 			  struct netlink_ext_ack *extack)
160 {
161 	struct tc_action_net *tn = net_generic(net, act_pedit_ops.net_id);
162 	bool bind = flags & TCA_ACT_FLAGS_BIND;
163 	struct tcf_chain *goto_ch = NULL;
164 	struct tcf_pedit_parms *oparms, *nparms;
165 	struct nlattr *tb[TCA_PEDIT_MAX + 1];
166 	struct tc_pedit *parm;
167 	struct nlattr *pattr;
168 	struct tcf_pedit *p;
169 	int ret = 0, err;
170 	int i, ksize;
171 	u32 index;
172 
173 	if (!nla) {
174 		NL_SET_ERR_MSG_MOD(extack, "Pedit requires attributes to be passed");
175 		return -EINVAL;
176 	}
177 
178 	err = nla_parse_nested_deprecated(tb, TCA_PEDIT_MAX, nla,
179 					  pedit_policy, NULL);
180 	if (err < 0)
181 		return err;
182 
183 	pattr = tb[TCA_PEDIT_PARMS];
184 	if (!pattr)
185 		pattr = tb[TCA_PEDIT_PARMS_EX];
186 	if (!pattr) {
187 		NL_SET_ERR_MSG_MOD(extack, "Missing required TCA_PEDIT_PARMS or TCA_PEDIT_PARMS_EX pedit attribute");
188 		return -EINVAL;
189 	}
190 
191 	parm = nla_data(pattr);
192 
193 	index = parm->index;
194 	err = tcf_idr_check_alloc(tn, &index, a, bind);
195 	if (!err) {
196 		ret = tcf_idr_create_from_flags(tn, index, est, a,
197 						&act_pedit_ops, bind, flags);
198 		if (ret) {
199 			tcf_idr_cleanup(tn, index);
200 			return ret;
201 		}
202 		ret = ACT_P_CREATED;
203 	} else if (err > 0) {
204 		if (bind)
205 			return 0;
206 		if (!(flags & TCA_ACT_FLAGS_REPLACE)) {
207 			ret = -EEXIST;
208 			goto out_release;
209 		}
210 	} else {
211 		return err;
212 	}
213 
214 	if (!parm->nkeys) {
215 		NL_SET_ERR_MSG_MOD(extack, "Pedit requires keys to be passed");
216 		ret = -EINVAL;
217 		goto out_release;
218 	}
219 	ksize = parm->nkeys * sizeof(struct tc_pedit_key);
220 	if (nla_len(pattr) < sizeof(*parm) + ksize) {
221 		NL_SET_ERR_MSG_ATTR(extack, pattr, "Length of TCA_PEDIT_PARMS or TCA_PEDIT_PARMS_EX pedit attribute is invalid");
222 		ret = -EINVAL;
223 		goto out_release;
224 	}
225 
226 	nparms = kzalloc(sizeof(*nparms), GFP_KERNEL);
227 	if (!nparms) {
228 		ret = -ENOMEM;
229 		goto out_release;
230 	}
231 
232 	nparms->tcfp_keys_ex =
233 		tcf_pedit_keys_ex_parse(tb[TCA_PEDIT_KEYS_EX], parm->nkeys, extack);
234 	if (IS_ERR(nparms->tcfp_keys_ex)) {
235 		ret = PTR_ERR(nparms->tcfp_keys_ex);
236 		goto out_free;
237 	}
238 
239 	err = tcf_action_check_ctrlact(parm->action, tp, &goto_ch, extack);
240 	if (err < 0) {
241 		ret = err;
242 		goto out_free_ex;
243 	}
244 
245 	nparms->tcfp_off_max_hint = 0;
246 	nparms->tcfp_flags = parm->flags;
247 	nparms->tcfp_nkeys = parm->nkeys;
248 
249 	nparms->tcfp_keys = kmemdup(parm->keys, ksize, GFP_KERNEL);
250 	if (!nparms->tcfp_keys) {
251 		ret = -ENOMEM;
252 		goto put_chain;
253 	}
254 
255 	for (i = 0; i < nparms->tcfp_nkeys; ++i) {
256 		u32 offmask = nparms->tcfp_keys[i].offmask;
257 		u32 cur = nparms->tcfp_keys[i].off;
258 
259 		/* The AT option can be added to static offsets in the datapath */
260 		if (!offmask && cur % 4) {
261 			NL_SET_ERR_MSG_MOD(extack, "Offsets must be on 32bit boundaries");
262 			ret = -EINVAL;
263 			goto out_free_keys;
264 		}
265 
266 		/* sanitize the shift value for any later use */
267 		nparms->tcfp_keys[i].shift = min_t(size_t,
268 						   BITS_PER_TYPE(int) - 1,
269 						   nparms->tcfp_keys[i].shift);
270 
271 		/* The AT option can read a single byte, we can bound the actual
272 		 * value with uchar max.
273 		 */
274 		cur += (0xff & offmask) >> nparms->tcfp_keys[i].shift;
275 
276 		/* Each key touches 4 bytes starting from the computed offset */
277 		nparms->tcfp_off_max_hint =
278 			max(nparms->tcfp_off_max_hint, cur + 4);
279 	}
280 
281 	p = to_pedit(*a);
282 
283 	spin_lock_bh(&p->tcf_lock);
284 	goto_ch = tcf_action_set_ctrlact(*a, parm->action, goto_ch);
285 	oparms = rcu_replace_pointer(p->parms, nparms, 1);
286 	spin_unlock_bh(&p->tcf_lock);
287 
288 	if (oparms)
289 		call_rcu(&oparms->rcu, tcf_pedit_cleanup_rcu);
290 
291 	if (goto_ch)
292 		tcf_chain_put_by_act(goto_ch);
293 
294 	return ret;
295 
296 out_free_keys:
297 	kfree(nparms->tcfp_keys);
298 put_chain:
299 	if (goto_ch)
300 		tcf_chain_put_by_act(goto_ch);
301 out_free_ex:
302 	kfree(nparms->tcfp_keys_ex);
303 out_free:
304 	kfree(nparms);
305 out_release:
306 	tcf_idr_release(*a, bind);
307 	return ret;
308 }
309 
310 static void tcf_pedit_cleanup(struct tc_action *a)
311 {
312 	struct tcf_pedit *p = to_pedit(a);
313 	struct tcf_pedit_parms *parms;
314 
315 	parms = rcu_dereference_protected(p->parms, 1);
316 
317 	if (parms)
318 		call_rcu(&parms->rcu, tcf_pedit_cleanup_rcu);
319 }
320 
321 static bool offset_valid(struct sk_buff *skb, int offset)
322 {
323 	if (offset > 0 && offset > skb->len)
324 		return false;
325 
326 	if  (offset < 0 && -offset > skb_headroom(skb))
327 		return false;
328 
329 	return true;
330 }
331 
332 static int pedit_l4_skb_offset(struct sk_buff *skb, int *hoffset, const int header_type)
333 {
334 	const int noff = skb_network_offset(skb);
335 	int ret = -EINVAL;
336 	struct iphdr _iph;
337 
338 	switch (skb->protocol) {
339 	case htons(ETH_P_IP): {
340 		const struct iphdr *iph = skb_header_pointer(skb, noff, sizeof(_iph), &_iph);
341 
342 		if (!iph)
343 			goto out;
344 		*hoffset = noff + iph->ihl * 4;
345 		ret = 0;
346 		break;
347 	}
348 	case htons(ETH_P_IPV6):
349 		ret = ipv6_find_hdr(skb, hoffset, header_type, NULL, NULL) == header_type ? 0 : -EINVAL;
350 		break;
351 	}
352 out:
353 	return ret;
354 }
355 
356 static int pedit_skb_hdr_offset(struct sk_buff *skb,
357 				 enum pedit_header_type htype, int *hoffset)
358 {
359 	int ret = -EINVAL;
360 	/* 'htype' is validated in the netlink parsing */
361 	switch (htype) {
362 	case TCA_PEDIT_KEY_EX_HDR_TYPE_ETH:
363 		if (skb_mac_header_was_set(skb)) {
364 			*hoffset = skb_mac_offset(skb);
365 			ret = 0;
366 		}
367 		break;
368 	case TCA_PEDIT_KEY_EX_HDR_TYPE_NETWORK:
369 	case TCA_PEDIT_KEY_EX_HDR_TYPE_IP4:
370 	case TCA_PEDIT_KEY_EX_HDR_TYPE_IP6:
371 		*hoffset = skb_network_offset(skb);
372 		ret = 0;
373 		break;
374 	case TCA_PEDIT_KEY_EX_HDR_TYPE_TCP:
375 		ret = pedit_l4_skb_offset(skb, hoffset, IPPROTO_TCP);
376 		break;
377 	case TCA_PEDIT_KEY_EX_HDR_TYPE_UDP:
378 		ret = pedit_l4_skb_offset(skb, hoffset, IPPROTO_UDP);
379 		break;
380 	default:
381 		break;
382 	}
383 	return ret;
384 }
385 
386 TC_INDIRECT_SCOPE int tcf_pedit_act(struct sk_buff *skb,
387 				    const struct tc_action *a,
388 				    struct tcf_result *res)
389 {
390 	enum pedit_header_type htype = TCA_PEDIT_KEY_EX_HDR_TYPE_NETWORK;
391 	enum pedit_cmd cmd = TCA_PEDIT_KEY_EX_CMD_SET;
392 	struct tcf_pedit *p = to_pedit(a);
393 	struct tcf_pedit_key_ex *tkey_ex;
394 	struct tcf_pedit_parms *parms;
395 	struct tc_pedit_key *tkey;
396 	u32 max_offset;
397 	int i;
398 
399 	parms = rcu_dereference_bh(p->parms);
400 
401 	max_offset = (skb_transport_header_was_set(skb) ?
402 		      skb_transport_offset(skb) :
403 		      skb_network_offset(skb)) +
404 		     parms->tcfp_off_max_hint;
405 	if (skb_ensure_writable(skb, min(skb->len, max_offset)))
406 		goto done;
407 
408 	tcf_lastuse_update(&p->tcf_tm);
409 	tcf_action_update_bstats(&p->common, skb);
410 
411 	tkey = parms->tcfp_keys;
412 	tkey_ex = parms->tcfp_keys_ex;
413 
414 	for (i = parms->tcfp_nkeys; i > 0; i--, tkey++) {
415 		int offset = tkey->off;
416 		int hoffset = 0;
417 		u32 *ptr, hdata;
418 		u32 val;
419 		int rc;
420 
421 		if (tkey_ex) {
422 			htype = tkey_ex->htype;
423 			cmd = tkey_ex->cmd;
424 
425 			tkey_ex++;
426 		}
427 
428 		rc = pedit_skb_hdr_offset(skb, htype, &hoffset);
429 		if (rc) {
430 			pr_info_ratelimited("tc action pedit unable to extract header offset for header type (0x%x)\n", htype);
431 			goto bad;
432 		}
433 
434 		if (tkey->offmask) {
435 			u8 *d, _d;
436 
437 			if (!offset_valid(skb, hoffset + tkey->at)) {
438 				pr_info_ratelimited("tc action pedit 'at' offset %d out of bounds\n",
439 						    hoffset + tkey->at);
440 				goto bad;
441 			}
442 			d = skb_header_pointer(skb, hoffset + tkey->at,
443 					       sizeof(_d), &_d);
444 			if (!d)
445 				goto bad;
446 
447 			offset += (*d & tkey->offmask) >> tkey->shift;
448 			if (offset % 4) {
449 				pr_info_ratelimited("tc action pedit offset must be on 32 bit boundaries\n");
450 				goto bad;
451 			}
452 		}
453 
454 		if (!offset_valid(skb, hoffset + offset)) {
455 			pr_info_ratelimited("tc action pedit offset %d out of bounds\n", hoffset + offset);
456 			goto bad;
457 		}
458 
459 		ptr = skb_header_pointer(skb, hoffset + offset,
460 					 sizeof(hdata), &hdata);
461 		if (!ptr)
462 			goto bad;
463 		/* just do it, baby */
464 		switch (cmd) {
465 		case TCA_PEDIT_KEY_EX_CMD_SET:
466 			val = tkey->val;
467 			break;
468 		case TCA_PEDIT_KEY_EX_CMD_ADD:
469 			val = (*ptr + tkey->val) & ~tkey->mask;
470 			break;
471 		default:
472 			pr_info_ratelimited("tc action pedit bad command (%d)\n", cmd);
473 			goto bad;
474 		}
475 
476 		*ptr = ((*ptr & tkey->mask) ^ val);
477 		if (ptr == &hdata)
478 			skb_store_bits(skb, hoffset + offset, ptr, 4);
479 	}
480 
481 	goto done;
482 
483 bad:
484 	tcf_action_inc_overlimit_qstats(&p->common);
485 done:
486 	return p->tcf_action;
487 }
488 
489 static void tcf_pedit_stats_update(struct tc_action *a, u64 bytes, u64 packets,
490 				   u64 drops, u64 lastuse, bool hw)
491 {
492 	struct tcf_pedit *d = to_pedit(a);
493 	struct tcf_t *tm = &d->tcf_tm;
494 
495 	tcf_action_update_stats(a, bytes, packets, drops, hw);
496 	tm->lastuse = max_t(u64, tm->lastuse, lastuse);
497 }
498 
499 static int tcf_pedit_dump(struct sk_buff *skb, struct tc_action *a,
500 			  int bind, int ref)
501 {
502 	unsigned char *b = skb_tail_pointer(skb);
503 	struct tcf_pedit *p = to_pedit(a);
504 	struct tcf_pedit_parms *parms;
505 	struct tc_pedit *opt;
506 	struct tcf_t t;
507 	int s;
508 
509 	spin_lock_bh(&p->tcf_lock);
510 	parms = rcu_dereference_protected(p->parms, 1);
511 	s = struct_size(opt, keys, parms->tcfp_nkeys);
512 
513 	opt = kzalloc(s, GFP_ATOMIC);
514 	if (unlikely(!opt)) {
515 		spin_unlock_bh(&p->tcf_lock);
516 		return -ENOBUFS;
517 	}
518 
519 	memcpy(opt->keys, parms->tcfp_keys,
520 	       flex_array_size(opt, keys, parms->tcfp_nkeys));
521 	opt->index = p->tcf_index;
522 	opt->nkeys = parms->tcfp_nkeys;
523 	opt->flags = parms->tcfp_flags;
524 	opt->action = p->tcf_action;
525 	opt->refcnt = refcount_read(&p->tcf_refcnt) - ref;
526 	opt->bindcnt = atomic_read(&p->tcf_bindcnt) - bind;
527 
528 	if (parms->tcfp_keys_ex) {
529 		if (tcf_pedit_key_ex_dump(skb, parms->tcfp_keys_ex,
530 					  parms->tcfp_nkeys))
531 			goto nla_put_failure;
532 
533 		if (nla_put(skb, TCA_PEDIT_PARMS_EX, s, opt))
534 			goto nla_put_failure;
535 	} else {
536 		if (nla_put(skb, TCA_PEDIT_PARMS, s, opt))
537 			goto nla_put_failure;
538 	}
539 
540 	tcf_tm_dump(&t, &p->tcf_tm);
541 	if (nla_put_64bit(skb, TCA_PEDIT_TM, sizeof(t), &t, TCA_PEDIT_PAD))
542 		goto nla_put_failure;
543 	spin_unlock_bh(&p->tcf_lock);
544 
545 	kfree(opt);
546 	return skb->len;
547 
548 nla_put_failure:
549 	spin_unlock_bh(&p->tcf_lock);
550 	nlmsg_trim(skb, b);
551 	kfree(opt);
552 	return -1;
553 }
554 
555 static int tcf_pedit_offload_act_setup(struct tc_action *act, void *entry_data,
556 				       u32 *index_inc, bool bind,
557 				       struct netlink_ext_ack *extack)
558 {
559 	if (bind) {
560 		struct flow_action_entry *entry = entry_data;
561 		int k;
562 
563 		for (k = 0; k < tcf_pedit_nkeys(act); k++) {
564 			switch (tcf_pedit_cmd(act, k)) {
565 			case TCA_PEDIT_KEY_EX_CMD_SET:
566 				entry->id = FLOW_ACTION_MANGLE;
567 				break;
568 			case TCA_PEDIT_KEY_EX_CMD_ADD:
569 				entry->id = FLOW_ACTION_ADD;
570 				break;
571 			default:
572 				NL_SET_ERR_MSG_MOD(extack, "Unsupported pedit command offload");
573 				return -EOPNOTSUPP;
574 			}
575 			entry->mangle.htype = tcf_pedit_htype(act, k);
576 			entry->mangle.mask = tcf_pedit_mask(act, k);
577 			entry->mangle.val = tcf_pedit_val(act, k);
578 			entry->mangle.offset = tcf_pedit_offset(act, k);
579 			entry->hw_stats = tc_act_hw_stats(act->hw_stats);
580 			entry++;
581 		}
582 		*index_inc = k;
583 	} else {
584 		struct flow_offload_action *fl_action = entry_data;
585 		u32 cmd = tcf_pedit_cmd(act, 0);
586 		int k;
587 
588 		switch (cmd) {
589 		case TCA_PEDIT_KEY_EX_CMD_SET:
590 			fl_action->id = FLOW_ACTION_MANGLE;
591 			break;
592 		case TCA_PEDIT_KEY_EX_CMD_ADD:
593 			fl_action->id = FLOW_ACTION_ADD;
594 			break;
595 		default:
596 			NL_SET_ERR_MSG_MOD(extack, "Unsupported pedit command offload");
597 			return -EOPNOTSUPP;
598 		}
599 
600 		for (k = 1; k < tcf_pedit_nkeys(act); k++) {
601 			if (cmd != tcf_pedit_cmd(act, k)) {
602 				NL_SET_ERR_MSG_MOD(extack, "Unsupported pedit command offload");
603 				return -EOPNOTSUPP;
604 			}
605 		}
606 	}
607 
608 	return 0;
609 }
610 
611 static struct tc_action_ops act_pedit_ops = {
612 	.kind		=	"pedit",
613 	.id		=	TCA_ID_PEDIT,
614 	.owner		=	THIS_MODULE,
615 	.act		=	tcf_pedit_act,
616 	.stats_update	=	tcf_pedit_stats_update,
617 	.dump		=	tcf_pedit_dump,
618 	.cleanup	=	tcf_pedit_cleanup,
619 	.init		=	tcf_pedit_init,
620 	.offload_act_setup =	tcf_pedit_offload_act_setup,
621 	.size		=	sizeof(struct tcf_pedit),
622 };
623 
624 static __net_init int pedit_init_net(struct net *net)
625 {
626 	struct tc_action_net *tn = net_generic(net, act_pedit_ops.net_id);
627 
628 	return tc_action_net_init(net, tn, &act_pedit_ops);
629 }
630 
631 static void __net_exit pedit_exit_net(struct list_head *net_list)
632 {
633 	tc_action_net_exit(net_list, act_pedit_ops.net_id);
634 }
635 
636 static struct pernet_operations pedit_net_ops = {
637 	.init = pedit_init_net,
638 	.exit_batch = pedit_exit_net,
639 	.id   = &act_pedit_ops.net_id,
640 	.size = sizeof(struct tc_action_net),
641 };
642 
643 MODULE_AUTHOR("Jamal Hadi Salim(2002-4)");
644 MODULE_DESCRIPTION("Generic Packet Editor actions");
645 MODULE_LICENSE("GPL");
646 
647 static int __init pedit_init_module(void)
648 {
649 	return tcf_register_action(&act_pedit_ops, &pedit_net_ops);
650 }
651 
652 static void __exit pedit_cleanup_module(void)
653 {
654 	tcf_unregister_action(&act_pedit_ops, &pedit_net_ops);
655 }
656 
657 module_init(pedit_init_module);
658 module_exit(pedit_cleanup_module);
659