2 * net/sched/em_meta.c Metadata ematch
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
9 * Authors: Thomas Graf <tgraf@suug.ch>
11 * ==========================================================================
13 * The metadata ematch compares two meta objects where each object
14 * represents either a meta value stored in the kernel or a static
15 * value provided by userspace. The objects are not provided by
16 * userspace itself but rather a definition providing the information
17 * to build them. Every object is of a certain type which must be
18 * equal to the object it is being compared to.
20 * The definition of a objects conists of the type (meta type), a
21 * identifier (meta id) and additional type specific information.
22 * The meta id is either TCF_META_TYPE_VALUE for values provided by
23 * userspace or a index to the meta operations table consisting of
24 * function pointers to type specific meta data collectors returning
25 * the value of the requested meta value.
28 * +-----------+ +-----------+
29 * | type: INT | | type: INT |
30 * def | id: INDEV | | id: VALUE |
31 * | data: | | data: 3 |
32 * +-----------+ +-----------+
34 * ---> meta_ops[INT][INDEV](...) |
38 * +-----------+ +-----------+
39 * | type: INT | | type: INT |
40 * obj | id: INDEV | | id: VALUE |
41 * | data: 2 |<--data got filled out | data: 3 |
42 * +-----------+ +-----------+
44 * --------------> 2 equals 3 <--------------
46 * This is a simplified schema, the complexity varies depending
47 * on the meta type. Obviously, the length of the data must also
48 * be provided for non-numeric types.
50 * Additionaly, type dependant modifiers such as shift operators
51 * or mask may be applied to extend the functionaliy. As of now,
52 * the variable length type supports shifting the byte string to
53 * the right, eating up any number of octets and thus supporting
54 * wildcard interface name comparisons such as "ppp%" matching
57 * NOTE: Certain meta values depend on other subsystems and are
58 * only available if that subsytem is enabled in the kernel.
61 #include <linux/config.h>
62 #include <linux/module.h>
63 #include <linux/types.h>
64 #include <linux/kernel.h>
65 #include <linux/sched.h>
66 #include <linux/string.h>
67 #include <linux/skbuff.h>
68 #include <linux/random.h>
69 #include <linux/tc_ematch/tc_em_meta.h>
71 #include <net/route.h>
72 #include <net/pkt_cls.h>
83 struct tcf_meta_val hdr
;
90 struct meta_value lvalue
;
91 struct meta_value rvalue
;
94 static inline int meta_id(struct meta_value
*v
)
96 return TCF_META_ID(v
->hdr
.kind
);
99 static inline int meta_type(struct meta_value
*v
)
101 return TCF_META_TYPE(v
->hdr
.kind
);
104 #define META_COLLECTOR(FUNC) static void meta_##FUNC(struct sk_buff *skb, \
105 struct tcf_pkt_info *info, struct meta_value *v, \
106 struct meta_obj *dst, int *err)
108 /**************************************************************************
109 * System status & misc
110 **************************************************************************/
112 META_COLLECTOR(int_random
)
114 get_random_bytes(&dst
->value
, sizeof(dst
->value
));
117 static inline unsigned long fixed_loadavg(int load
)
119 int rnd_load
= load
+ (FIXED_1
/200);
120 int rnd_frac
= ((rnd_load
& (FIXED_1
-1)) * 100) >> FSHIFT
;
122 return ((rnd_load
>> FSHIFT
) * 100) + rnd_frac
;
125 META_COLLECTOR(int_loadavg_0
)
127 dst
->value
= fixed_loadavg(avenrun
[0]);
130 META_COLLECTOR(int_loadavg_1
)
132 dst
->value
= fixed_loadavg(avenrun
[1]);
135 META_COLLECTOR(int_loadavg_2
)
137 dst
->value
= fixed_loadavg(avenrun
[2]);
140 /**************************************************************************
141 * Device names & indices
142 **************************************************************************/
144 static inline int int_dev(struct net_device
*dev
, struct meta_obj
*dst
)
146 if (unlikely(dev
== NULL
))
149 dst
->value
= dev
->ifindex
;
153 static inline int var_dev(struct net_device
*dev
, struct meta_obj
*dst
)
155 if (unlikely(dev
== NULL
))
158 dst
->value
= (unsigned long) dev
->name
;
159 dst
->len
= strlen(dev
->name
);
163 META_COLLECTOR(int_dev
)
165 *err
= int_dev(skb
->dev
, dst
);
168 META_COLLECTOR(var_dev
)
170 *err
= var_dev(skb
->dev
, dst
);
173 META_COLLECTOR(int_indev
)
175 *err
= int_dev(skb
->input_dev
, dst
);
178 META_COLLECTOR(var_indev
)
180 *err
= var_dev(skb
->input_dev
, dst
);
183 META_COLLECTOR(int_realdev
)
185 *err
= int_dev(skb
->real_dev
, dst
);
188 META_COLLECTOR(var_realdev
)
190 *err
= var_dev(skb
->real_dev
, dst
);
193 /**************************************************************************
195 **************************************************************************/
197 META_COLLECTOR(int_priority
)
199 dst
->value
= skb
->priority
;
202 META_COLLECTOR(int_protocol
)
204 /* Let userspace take care of the byte ordering */
205 dst
->value
= skb
->protocol
;
208 META_COLLECTOR(int_security
)
210 dst
->value
= skb
->security
;
213 META_COLLECTOR(int_pkttype
)
215 dst
->value
= skb
->pkt_type
;
218 META_COLLECTOR(int_pktlen
)
220 dst
->value
= skb
->len
;
223 META_COLLECTOR(int_datalen
)
225 dst
->value
= skb
->data_len
;
228 META_COLLECTOR(int_maclen
)
230 dst
->value
= skb
->mac_len
;
233 /**************************************************************************
235 **************************************************************************/
237 #ifdef CONFIG_NETFILTER
238 META_COLLECTOR(int_nfmark
)
240 dst
->value
= skb
->nfmark
;
244 /**************************************************************************
246 **************************************************************************/
248 META_COLLECTOR(int_tcindex
)
250 dst
->value
= skb
->tc_index
;
253 #ifdef CONFIG_NET_CLS_ACT
254 META_COLLECTOR(int_tcverd
)
256 dst
->value
= skb
->tc_verd
;
259 META_COLLECTOR(int_tcclassid
)
261 dst
->value
= skb
->tc_classid
;
265 /**************************************************************************
267 **************************************************************************/
269 #ifdef CONFIG_NET_CLS_ROUTE
270 META_COLLECTOR(int_rtclassid
)
272 if (unlikely(skb
->dst
== NULL
))
275 dst
->value
= skb
->dst
->tclassid
;
279 META_COLLECTOR(int_rtiif
)
281 if (unlikely(skb
->dst
== NULL
))
284 dst
->value
= ((struct rtable
*) skb
->dst
)->fl
.iif
;
287 /**************************************************************************
289 **************************************************************************/
291 #define SKIP_NONLOCAL(skb) \
292 if (unlikely(skb->sk == NULL)) { \
297 META_COLLECTOR(int_sk_family
)
300 dst
->value
= skb
->sk
->sk_family
;
303 META_COLLECTOR(int_sk_state
)
306 dst
->value
= skb
->sk
->sk_state
;
309 META_COLLECTOR(int_sk_reuse
)
312 dst
->value
= skb
->sk
->sk_reuse
;
315 META_COLLECTOR(int_sk_bound_if
)
318 /* No error if bound_dev_if is 0, legal userspace check */
319 dst
->value
= skb
->sk
->sk_bound_dev_if
;
322 META_COLLECTOR(var_sk_bound_if
)
326 if (skb
->sk
->sk_bound_dev_if
== 0) {
327 dst
->value
= (unsigned long) "any";
330 struct net_device
*dev
;
332 dev
= dev_get_by_index(skb
->sk
->sk_bound_dev_if
);
333 *err
= var_dev(dev
, dst
);
339 META_COLLECTOR(int_sk_refcnt
)
342 dst
->value
= atomic_read(&skb
->sk
->sk_refcnt
);
345 META_COLLECTOR(int_sk_rcvbuf
)
348 dst
->value
= skb
->sk
->sk_rcvbuf
;
351 META_COLLECTOR(int_sk_shutdown
)
354 dst
->value
= skb
->sk
->sk_shutdown
;
357 META_COLLECTOR(int_sk_proto
)
360 dst
->value
= skb
->sk
->sk_protocol
;
363 META_COLLECTOR(int_sk_type
)
366 dst
->value
= skb
->sk
->sk_type
;
369 META_COLLECTOR(int_sk_rmem_alloc
)
372 dst
->value
= atomic_read(&skb
->sk
->sk_rmem_alloc
);
375 META_COLLECTOR(int_sk_wmem_alloc
)
378 dst
->value
= atomic_read(&skb
->sk
->sk_wmem_alloc
);
381 META_COLLECTOR(int_sk_omem_alloc
)
384 dst
->value
= atomic_read(&skb
->sk
->sk_omem_alloc
);
387 META_COLLECTOR(int_sk_rcv_qlen
)
390 dst
->value
= skb
->sk
->sk_receive_queue
.qlen
;
393 META_COLLECTOR(int_sk_snd_qlen
)
396 dst
->value
= skb
->sk
->sk_write_queue
.qlen
;
399 META_COLLECTOR(int_sk_wmem_queued
)
402 dst
->value
= skb
->sk
->sk_wmem_queued
;
405 META_COLLECTOR(int_sk_fwd_alloc
)
408 dst
->value
= skb
->sk
->sk_forward_alloc
;
411 META_COLLECTOR(int_sk_sndbuf
)
414 dst
->value
= skb
->sk
->sk_sndbuf
;
417 META_COLLECTOR(int_sk_alloc
)
420 dst
->value
= skb
->sk
->sk_allocation
;
423 META_COLLECTOR(int_sk_route_caps
)
426 dst
->value
= skb
->sk
->sk_route_caps
;
429 META_COLLECTOR(int_sk_hashent
)
432 dst
->value
= skb
->sk
->sk_hashent
;
435 META_COLLECTOR(int_sk_lingertime
)
438 dst
->value
= skb
->sk
->sk_lingertime
/ HZ
;
441 META_COLLECTOR(int_sk_err_qlen
)
444 dst
->value
= skb
->sk
->sk_error_queue
.qlen
;
447 META_COLLECTOR(int_sk_ack_bl
)
450 dst
->value
= skb
->sk
->sk_ack_backlog
;
453 META_COLLECTOR(int_sk_max_ack_bl
)
456 dst
->value
= skb
->sk
->sk_max_ack_backlog
;
459 META_COLLECTOR(int_sk_prio
)
462 dst
->value
= skb
->sk
->sk_priority
;
465 META_COLLECTOR(int_sk_rcvlowat
)
468 dst
->value
= skb
->sk
->sk_rcvlowat
;
471 META_COLLECTOR(int_sk_rcvtimeo
)
474 dst
->value
= skb
->sk
->sk_rcvtimeo
/ HZ
;
477 META_COLLECTOR(int_sk_sndtimeo
)
480 dst
->value
= skb
->sk
->sk_sndtimeo
/ HZ
;
483 META_COLLECTOR(int_sk_sendmsg_off
)
486 dst
->value
= skb
->sk
->sk_sndmsg_off
;
489 META_COLLECTOR(int_sk_write_pend
)
492 dst
->value
= skb
->sk
->sk_write_pending
;
495 /**************************************************************************
496 * Meta value collectors assignment table
497 **************************************************************************/
501 void (*get
)(struct sk_buff
*, struct tcf_pkt_info
*,
502 struct meta_value
*, struct meta_obj
*, int *);
505 #define META_ID(name) TCF_META_ID_##name
506 #define META_FUNC(name) { .get = meta_##name }
508 /* Meta value operations table listing all meta value collectors and
509 * assigns them to a type and meta id. */
510 static struct meta_ops __meta_ops
[TCF_META_TYPE_MAX
+1][TCF_META_ID_MAX
+1] = {
511 [TCF_META_TYPE_VAR
] = {
512 [META_ID(DEV
)] = META_FUNC(var_dev
),
513 [META_ID(INDEV
)] = META_FUNC(var_indev
),
514 [META_ID(REALDEV
)] = META_FUNC(var_realdev
),
515 [META_ID(SK_BOUND_IF
)] = META_FUNC(var_sk_bound_if
),
517 [TCF_META_TYPE_INT
] = {
518 [META_ID(RANDOM
)] = META_FUNC(int_random
),
519 [META_ID(LOADAVG_0
)] = META_FUNC(int_loadavg_0
),
520 [META_ID(LOADAVG_1
)] = META_FUNC(int_loadavg_1
),
521 [META_ID(LOADAVG_2
)] = META_FUNC(int_loadavg_2
),
522 [META_ID(DEV
)] = META_FUNC(int_dev
),
523 [META_ID(INDEV
)] = META_FUNC(int_indev
),
524 [META_ID(REALDEV
)] = META_FUNC(int_realdev
),
525 [META_ID(PRIORITY
)] = META_FUNC(int_priority
),
526 [META_ID(PROTOCOL
)] = META_FUNC(int_protocol
),
527 [META_ID(SECURITY
)] = META_FUNC(int_security
),
528 [META_ID(PKTTYPE
)] = META_FUNC(int_pkttype
),
529 [META_ID(PKTLEN
)] = META_FUNC(int_pktlen
),
530 [META_ID(DATALEN
)] = META_FUNC(int_datalen
),
531 [META_ID(MACLEN
)] = META_FUNC(int_maclen
),
532 #ifdef CONFIG_NETFILTER
533 [META_ID(NFMARK
)] = META_FUNC(int_nfmark
),
535 [META_ID(TCINDEX
)] = META_FUNC(int_tcindex
),
536 #ifdef CONFIG_NET_CLS_ACT
537 [META_ID(TCVERDICT
)] = META_FUNC(int_tcverd
),
538 [META_ID(TCCLASSID
)] = META_FUNC(int_tcclassid
),
540 #ifdef CONFIG_NET_CLS_ROUTE
541 [META_ID(RTCLASSID
)] = META_FUNC(int_rtclassid
),
543 [META_ID(RTIIF
)] = META_FUNC(int_rtiif
),
544 [META_ID(SK_FAMILY
)] = META_FUNC(int_sk_family
),
545 [META_ID(SK_STATE
)] = META_FUNC(int_sk_state
),
546 [META_ID(SK_REUSE
)] = META_FUNC(int_sk_reuse
),
547 [META_ID(SK_BOUND_IF
)] = META_FUNC(int_sk_bound_if
),
548 [META_ID(SK_REFCNT
)] = META_FUNC(int_sk_refcnt
),
549 [META_ID(SK_RCVBUF
)] = META_FUNC(int_sk_rcvbuf
),
550 [META_ID(SK_SNDBUF
)] = META_FUNC(int_sk_sndbuf
),
551 [META_ID(SK_SHUTDOWN
)] = META_FUNC(int_sk_shutdown
),
552 [META_ID(SK_PROTO
)] = META_FUNC(int_sk_proto
),
553 [META_ID(SK_TYPE
)] = META_FUNC(int_sk_type
),
554 [META_ID(SK_RMEM_ALLOC
)] = META_FUNC(int_sk_rmem_alloc
),
555 [META_ID(SK_WMEM_ALLOC
)] = META_FUNC(int_sk_wmem_alloc
),
556 [META_ID(SK_OMEM_ALLOC
)] = META_FUNC(int_sk_omem_alloc
),
557 [META_ID(SK_WMEM_QUEUED
)] = META_FUNC(int_sk_wmem_queued
),
558 [META_ID(SK_RCV_QLEN
)] = META_FUNC(int_sk_rcv_qlen
),
559 [META_ID(SK_SND_QLEN
)] = META_FUNC(int_sk_snd_qlen
),
560 [META_ID(SK_ERR_QLEN
)] = META_FUNC(int_sk_err_qlen
),
561 [META_ID(SK_FORWARD_ALLOCS
)] = META_FUNC(int_sk_fwd_alloc
),
562 [META_ID(SK_ALLOCS
)] = META_FUNC(int_sk_alloc
),
563 [META_ID(SK_ROUTE_CAPS
)] = META_FUNC(int_sk_route_caps
),
564 [META_ID(SK_HASHENT
)] = META_FUNC(int_sk_hashent
),
565 [META_ID(SK_LINGERTIME
)] = META_FUNC(int_sk_lingertime
),
566 [META_ID(SK_ACK_BACKLOG
)] = META_FUNC(int_sk_ack_bl
),
567 [META_ID(SK_MAX_ACK_BACKLOG
)] = META_FUNC(int_sk_max_ack_bl
),
568 [META_ID(SK_PRIO
)] = META_FUNC(int_sk_prio
),
569 [META_ID(SK_RCVLOWAT
)] = META_FUNC(int_sk_rcvlowat
),
570 [META_ID(SK_RCVTIMEO
)] = META_FUNC(int_sk_rcvtimeo
),
571 [META_ID(SK_SNDTIMEO
)] = META_FUNC(int_sk_sndtimeo
),
572 [META_ID(SK_SENDMSG_OFF
)] = META_FUNC(int_sk_sendmsg_off
),
573 [META_ID(SK_WRITE_PENDING
)] = META_FUNC(int_sk_write_pend
),
577 static inline struct meta_ops
* meta_ops(struct meta_value
*val
)
579 return &__meta_ops
[meta_type(val
)][meta_id(val
)];
582 /**************************************************************************
583 * Type specific operations for TCF_META_TYPE_VAR
584 **************************************************************************/
586 static int meta_var_compare(struct meta_obj
*a
, struct meta_obj
*b
)
588 int r
= a
->len
- b
->len
;
591 r
= memcmp((void *) a
->value
, (void *) b
->value
, a
->len
);
596 static int meta_var_change(struct meta_value
*dst
, struct rtattr
*rta
)
598 int len
= RTA_PAYLOAD(rta
);
600 dst
->val
= (unsigned long) kmalloc(len
, GFP_KERNEL
);
603 memcpy((void *) dst
->val
, RTA_DATA(rta
), len
);
608 static void meta_var_destroy(struct meta_value
*v
)
611 kfree((void *) v
->val
);
614 static void meta_var_apply_extras(struct meta_value
*v
,
615 struct meta_obj
*dst
)
617 int shift
= v
->hdr
.shift
;
619 if (shift
&& shift
< dst
->len
)
623 static int meta_var_dump(struct sk_buff
*skb
, struct meta_value
*v
, int tlv
)
625 if (v
->val
&& v
->len
)
626 RTA_PUT(skb
, tlv
, v
->len
, (void *) v
->val
);
633 /**************************************************************************
634 * Type specific operations for TCF_META_TYPE_INT
635 **************************************************************************/
637 static int meta_int_compare(struct meta_obj
*a
, struct meta_obj
*b
)
639 /* Let gcc optimize it, the unlikely is not really based on
640 * some numbers but jump free code for mismatches seems
642 if (unlikely(a
->value
== b
->value
))
644 else if (a
->value
< b
->value
)
650 static int meta_int_change(struct meta_value
*dst
, struct rtattr
*rta
)
652 if (RTA_PAYLOAD(rta
) >= sizeof(unsigned long)) {
653 dst
->val
= *(unsigned long *) RTA_DATA(rta
);
654 dst
->len
= sizeof(unsigned long);
655 } else if (RTA_PAYLOAD(rta
) == sizeof(u32
)) {
656 dst
->val
= *(u32
*) RTA_DATA(rta
);
657 dst
->len
= sizeof(u32
);
664 static void meta_int_apply_extras(struct meta_value
*v
,
665 struct meta_obj
*dst
)
668 dst
->value
>>= v
->hdr
.shift
;
671 dst
->value
&= v
->val
;
674 static int meta_int_dump(struct sk_buff
*skb
, struct meta_value
*v
, int tlv
)
676 if (v
->len
== sizeof(unsigned long))
677 RTA_PUT(skb
, tlv
, sizeof(unsigned long), &v
->val
);
678 else if (v
->len
== sizeof(u32
)) {
680 RTA_PUT(skb
, tlv
, sizeof(d
), &d
);
689 /**************************************************************************
690 * Type specific operations table
691 **************************************************************************/
695 void (*destroy
)(struct meta_value
*);
696 int (*compare
)(struct meta_obj
*, struct meta_obj
*);
697 int (*change
)(struct meta_value
*, struct rtattr
*);
698 void (*apply_extras
)(struct meta_value
*, struct meta_obj
*);
699 int (*dump
)(struct sk_buff
*, struct meta_value
*, int);
702 static struct meta_type_ops __meta_type_ops
[TCF_META_TYPE_MAX
+1] = {
703 [TCF_META_TYPE_VAR
] = {
704 .destroy
= meta_var_destroy
,
705 .compare
= meta_var_compare
,
706 .change
= meta_var_change
,
707 .apply_extras
= meta_var_apply_extras
,
708 .dump
= meta_var_dump
710 [TCF_META_TYPE_INT
] = {
711 .compare
= meta_int_compare
,
712 .change
= meta_int_change
,
713 .apply_extras
= meta_int_apply_extras
,
714 .dump
= meta_int_dump
718 static inline struct meta_type_ops
* meta_type_ops(struct meta_value
*v
)
720 return &__meta_type_ops
[meta_type(v
)];
723 /**************************************************************************
725 **************************************************************************/
727 static inline int meta_get(struct sk_buff
*skb
, struct tcf_pkt_info
*info
,
728 struct meta_value
*v
, struct meta_obj
*dst
)
732 if (meta_id(v
) == TCF_META_ID_VALUE
) {
738 meta_ops(v
)->get(skb
, info
, v
, dst
, &err
);
742 if (meta_type_ops(v
)->apply_extras
)
743 meta_type_ops(v
)->apply_extras(v
, dst
);
748 static int em_meta_match(struct sk_buff
*skb
, struct tcf_ematch
*m
,
749 struct tcf_pkt_info
*info
)
752 struct meta_match
*meta
= (struct meta_match
*) m
->data
;
753 struct meta_obj l_value
, r_value
;
755 if (meta_get(skb
, info
, &meta
->lvalue
, &l_value
) < 0 ||
756 meta_get(skb
, info
, &meta
->rvalue
, &r_value
) < 0)
759 r
= meta_type_ops(&meta
->lvalue
)->compare(&l_value
, &r_value
);
761 switch (meta
->lvalue
.hdr
.op
) {
773 static inline void meta_delete(struct meta_match
*meta
)
775 struct meta_type_ops
*ops
= meta_type_ops(&meta
->lvalue
);
777 if (ops
&& ops
->destroy
) {
778 ops
->destroy(&meta
->lvalue
);
779 ops
->destroy(&meta
->rvalue
);
785 static inline int meta_change_data(struct meta_value
*dst
, struct rtattr
*rta
)
788 if (RTA_PAYLOAD(rta
) == 0)
791 return meta_type_ops(dst
)->change(dst
, rta
);
797 static inline int meta_is_supported(struct meta_value
*val
)
799 return (!meta_id(val
) || meta_ops(val
)->get
);
802 static int em_meta_change(struct tcf_proto
*tp
, void *data
, int len
,
803 struct tcf_ematch
*m
)
806 struct rtattr
*tb
[TCA_EM_META_MAX
];
807 struct tcf_meta_hdr
*hdr
;
808 struct meta_match
*meta
= NULL
;
810 if (rtattr_parse(tb
, TCA_EM_META_MAX
, data
, len
) < 0)
813 if (tb
[TCA_EM_META_HDR
-1] == NULL
||
814 RTA_PAYLOAD(tb
[TCA_EM_META_HDR
-1]) < sizeof(*hdr
))
816 hdr
= RTA_DATA(tb
[TCA_EM_META_HDR
-1]);
818 if (TCF_META_TYPE(hdr
->left
.kind
) != TCF_META_TYPE(hdr
->right
.kind
) ||
819 TCF_META_TYPE(hdr
->left
.kind
) > TCF_META_TYPE_MAX
||
820 TCF_META_ID(hdr
->left
.kind
) > TCF_META_ID_MAX
||
821 TCF_META_ID(hdr
->right
.kind
) > TCF_META_ID_MAX
)
824 meta
= kmalloc(sizeof(*meta
), GFP_KERNEL
);
827 memset(meta
, 0, sizeof(*meta
));
829 memcpy(&meta
->lvalue
.hdr
, &hdr
->left
, sizeof(hdr
->left
));
830 memcpy(&meta
->rvalue
.hdr
, &hdr
->right
, sizeof(hdr
->right
));
832 if (!meta_is_supported(&meta
->lvalue
) ||
833 !meta_is_supported(&meta
->rvalue
)) {
838 if (meta_change_data(&meta
->lvalue
, tb
[TCA_EM_META_LVALUE
-1]) < 0 ||
839 meta_change_data(&meta
->rvalue
, tb
[TCA_EM_META_RVALUE
-1]) < 0)
842 m
->datalen
= sizeof(*meta
);
843 m
->data
= (unsigned long) meta
;
852 static void em_meta_destroy(struct tcf_proto
*tp
, struct tcf_ematch
*m
)
855 meta_delete((struct meta_match
*) m
->data
);
858 static int em_meta_dump(struct sk_buff
*skb
, struct tcf_ematch
*em
)
860 struct meta_match
*meta
= (struct meta_match
*) em
->data
;
861 struct tcf_meta_hdr hdr
;
862 struct meta_type_ops
*ops
;
864 memset(&hdr
, 0, sizeof(hdr
));
865 memcpy(&hdr
.left
, &meta
->lvalue
.hdr
, sizeof(hdr
.left
));
866 memcpy(&hdr
.right
, &meta
->rvalue
.hdr
, sizeof(hdr
.right
));
868 RTA_PUT(skb
, TCA_EM_META_HDR
, sizeof(hdr
), &hdr
);
870 ops
= meta_type_ops(&meta
->lvalue
);
871 if (ops
->dump(skb
, &meta
->lvalue
, TCA_EM_META_LVALUE
) < 0 ||
872 ops
->dump(skb
, &meta
->rvalue
, TCA_EM_META_RVALUE
) < 0)
881 static struct tcf_ematch_ops em_meta_ops
= {
883 .change
= em_meta_change
,
884 .match
= em_meta_match
,
885 .destroy
= em_meta_destroy
,
886 .dump
= em_meta_dump
,
887 .owner
= THIS_MODULE
,
888 .link
= LIST_HEAD_INIT(em_meta_ops
.link
)
891 static int __init
init_em_meta(void)
893 return tcf_em_register(&em_meta_ops
);
896 static void __exit
exit_em_meta(void)
898 tcf_em_unregister(&em_meta_ops
);
901 MODULE_LICENSE("GPL");
903 module_init(init_em_meta
);
904 module_exit(exit_em_meta
);