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_pkttype
)
210 dst
->value
= skb
->pkt_type
;
213 META_COLLECTOR(int_pktlen
)
215 dst
->value
= skb
->len
;
218 META_COLLECTOR(int_datalen
)
220 dst
->value
= skb
->data_len
;
223 META_COLLECTOR(int_maclen
)
225 dst
->value
= skb
->mac_len
;
228 /**************************************************************************
230 **************************************************************************/
232 #ifdef CONFIG_NETFILTER
233 META_COLLECTOR(int_nfmark
)
235 dst
->value
= skb
->nfmark
;
239 /**************************************************************************
241 **************************************************************************/
243 META_COLLECTOR(int_tcindex
)
245 dst
->value
= skb
->tc_index
;
248 #ifdef CONFIG_NET_CLS_ACT
249 META_COLLECTOR(int_tcverd
)
251 dst
->value
= skb
->tc_verd
;
255 /**************************************************************************
257 **************************************************************************/
259 #ifdef CONFIG_NET_CLS_ROUTE
260 META_COLLECTOR(int_rtclassid
)
262 if (unlikely(skb
->dst
== NULL
))
265 dst
->value
= skb
->dst
->tclassid
;
269 META_COLLECTOR(int_rtiif
)
271 if (unlikely(skb
->dst
== NULL
))
274 dst
->value
= ((struct rtable
*) skb
->dst
)->fl
.iif
;
277 /**************************************************************************
279 **************************************************************************/
281 #define SKIP_NONLOCAL(skb) \
282 if (unlikely(skb->sk == NULL)) { \
287 META_COLLECTOR(int_sk_family
)
290 dst
->value
= skb
->sk
->sk_family
;
293 META_COLLECTOR(int_sk_state
)
296 dst
->value
= skb
->sk
->sk_state
;
299 META_COLLECTOR(int_sk_reuse
)
302 dst
->value
= skb
->sk
->sk_reuse
;
305 META_COLLECTOR(int_sk_bound_if
)
308 /* No error if bound_dev_if is 0, legal userspace check */
309 dst
->value
= skb
->sk
->sk_bound_dev_if
;
312 META_COLLECTOR(var_sk_bound_if
)
316 if (skb
->sk
->sk_bound_dev_if
== 0) {
317 dst
->value
= (unsigned long) "any";
320 struct net_device
*dev
;
322 dev
= dev_get_by_index(skb
->sk
->sk_bound_dev_if
);
323 *err
= var_dev(dev
, dst
);
329 META_COLLECTOR(int_sk_refcnt
)
332 dst
->value
= atomic_read(&skb
->sk
->sk_refcnt
);
335 META_COLLECTOR(int_sk_rcvbuf
)
338 dst
->value
= skb
->sk
->sk_rcvbuf
;
341 META_COLLECTOR(int_sk_shutdown
)
344 dst
->value
= skb
->sk
->sk_shutdown
;
347 META_COLLECTOR(int_sk_proto
)
350 dst
->value
= skb
->sk
->sk_protocol
;
353 META_COLLECTOR(int_sk_type
)
356 dst
->value
= skb
->sk
->sk_type
;
359 META_COLLECTOR(int_sk_rmem_alloc
)
362 dst
->value
= atomic_read(&skb
->sk
->sk_rmem_alloc
);
365 META_COLLECTOR(int_sk_wmem_alloc
)
368 dst
->value
= atomic_read(&skb
->sk
->sk_wmem_alloc
);
371 META_COLLECTOR(int_sk_omem_alloc
)
374 dst
->value
= atomic_read(&skb
->sk
->sk_omem_alloc
);
377 META_COLLECTOR(int_sk_rcv_qlen
)
380 dst
->value
= skb
->sk
->sk_receive_queue
.qlen
;
383 META_COLLECTOR(int_sk_snd_qlen
)
386 dst
->value
= skb
->sk
->sk_write_queue
.qlen
;
389 META_COLLECTOR(int_sk_wmem_queued
)
392 dst
->value
= skb
->sk
->sk_wmem_queued
;
395 META_COLLECTOR(int_sk_fwd_alloc
)
398 dst
->value
= skb
->sk
->sk_forward_alloc
;
401 META_COLLECTOR(int_sk_sndbuf
)
404 dst
->value
= skb
->sk
->sk_sndbuf
;
407 META_COLLECTOR(int_sk_alloc
)
410 dst
->value
= skb
->sk
->sk_allocation
;
413 META_COLLECTOR(int_sk_route_caps
)
416 dst
->value
= skb
->sk
->sk_route_caps
;
419 META_COLLECTOR(int_sk_hashent
)
422 dst
->value
= skb
->sk
->sk_hashent
;
425 META_COLLECTOR(int_sk_lingertime
)
428 dst
->value
= skb
->sk
->sk_lingertime
/ HZ
;
431 META_COLLECTOR(int_sk_err_qlen
)
434 dst
->value
= skb
->sk
->sk_error_queue
.qlen
;
437 META_COLLECTOR(int_sk_ack_bl
)
440 dst
->value
= skb
->sk
->sk_ack_backlog
;
443 META_COLLECTOR(int_sk_max_ack_bl
)
446 dst
->value
= skb
->sk
->sk_max_ack_backlog
;
449 META_COLLECTOR(int_sk_prio
)
452 dst
->value
= skb
->sk
->sk_priority
;
455 META_COLLECTOR(int_sk_rcvlowat
)
458 dst
->value
= skb
->sk
->sk_rcvlowat
;
461 META_COLLECTOR(int_sk_rcvtimeo
)
464 dst
->value
= skb
->sk
->sk_rcvtimeo
/ HZ
;
467 META_COLLECTOR(int_sk_sndtimeo
)
470 dst
->value
= skb
->sk
->sk_sndtimeo
/ HZ
;
473 META_COLLECTOR(int_sk_sendmsg_off
)
476 dst
->value
= skb
->sk
->sk_sndmsg_off
;
479 META_COLLECTOR(int_sk_write_pend
)
482 dst
->value
= skb
->sk
->sk_write_pending
;
485 /**************************************************************************
486 * Meta value collectors assignment table
487 **************************************************************************/
491 void (*get
)(struct sk_buff
*, struct tcf_pkt_info
*,
492 struct meta_value
*, struct meta_obj
*, int *);
495 #define META_ID(name) TCF_META_ID_##name
496 #define META_FUNC(name) { .get = meta_##name }
498 /* Meta value operations table listing all meta value collectors and
499 * assigns them to a type and meta id. */
500 static struct meta_ops __meta_ops
[TCF_META_TYPE_MAX
+1][TCF_META_ID_MAX
+1] = {
501 [TCF_META_TYPE_VAR
] = {
502 [META_ID(DEV
)] = META_FUNC(var_dev
),
503 [META_ID(INDEV
)] = META_FUNC(var_indev
),
504 [META_ID(REALDEV
)] = META_FUNC(var_realdev
),
505 [META_ID(SK_BOUND_IF
)] = META_FUNC(var_sk_bound_if
),
507 [TCF_META_TYPE_INT
] = {
508 [META_ID(RANDOM
)] = META_FUNC(int_random
),
509 [META_ID(LOADAVG_0
)] = META_FUNC(int_loadavg_0
),
510 [META_ID(LOADAVG_1
)] = META_FUNC(int_loadavg_1
),
511 [META_ID(LOADAVG_2
)] = META_FUNC(int_loadavg_2
),
512 [META_ID(DEV
)] = META_FUNC(int_dev
),
513 [META_ID(INDEV
)] = META_FUNC(int_indev
),
514 [META_ID(REALDEV
)] = META_FUNC(int_realdev
),
515 [META_ID(PRIORITY
)] = META_FUNC(int_priority
),
516 [META_ID(PROTOCOL
)] = META_FUNC(int_protocol
),
517 [META_ID(PKTTYPE
)] = META_FUNC(int_pkttype
),
518 [META_ID(PKTLEN
)] = META_FUNC(int_pktlen
),
519 [META_ID(DATALEN
)] = META_FUNC(int_datalen
),
520 [META_ID(MACLEN
)] = META_FUNC(int_maclen
),
521 #ifdef CONFIG_NETFILTER
522 [META_ID(NFMARK
)] = META_FUNC(int_nfmark
),
524 [META_ID(TCINDEX
)] = META_FUNC(int_tcindex
),
525 #ifdef CONFIG_NET_CLS_ACT
526 [META_ID(TCVERDICT
)] = META_FUNC(int_tcverd
),
528 #ifdef CONFIG_NET_CLS_ROUTE
529 [META_ID(RTCLASSID
)] = META_FUNC(int_rtclassid
),
531 [META_ID(RTIIF
)] = META_FUNC(int_rtiif
),
532 [META_ID(SK_FAMILY
)] = META_FUNC(int_sk_family
),
533 [META_ID(SK_STATE
)] = META_FUNC(int_sk_state
),
534 [META_ID(SK_REUSE
)] = META_FUNC(int_sk_reuse
),
535 [META_ID(SK_BOUND_IF
)] = META_FUNC(int_sk_bound_if
),
536 [META_ID(SK_REFCNT
)] = META_FUNC(int_sk_refcnt
),
537 [META_ID(SK_RCVBUF
)] = META_FUNC(int_sk_rcvbuf
),
538 [META_ID(SK_SNDBUF
)] = META_FUNC(int_sk_sndbuf
),
539 [META_ID(SK_SHUTDOWN
)] = META_FUNC(int_sk_shutdown
),
540 [META_ID(SK_PROTO
)] = META_FUNC(int_sk_proto
),
541 [META_ID(SK_TYPE
)] = META_FUNC(int_sk_type
),
542 [META_ID(SK_RMEM_ALLOC
)] = META_FUNC(int_sk_rmem_alloc
),
543 [META_ID(SK_WMEM_ALLOC
)] = META_FUNC(int_sk_wmem_alloc
),
544 [META_ID(SK_OMEM_ALLOC
)] = META_FUNC(int_sk_omem_alloc
),
545 [META_ID(SK_WMEM_QUEUED
)] = META_FUNC(int_sk_wmem_queued
),
546 [META_ID(SK_RCV_QLEN
)] = META_FUNC(int_sk_rcv_qlen
),
547 [META_ID(SK_SND_QLEN
)] = META_FUNC(int_sk_snd_qlen
),
548 [META_ID(SK_ERR_QLEN
)] = META_FUNC(int_sk_err_qlen
),
549 [META_ID(SK_FORWARD_ALLOCS
)] = META_FUNC(int_sk_fwd_alloc
),
550 [META_ID(SK_ALLOCS
)] = META_FUNC(int_sk_alloc
),
551 [META_ID(SK_ROUTE_CAPS
)] = META_FUNC(int_sk_route_caps
),
552 [META_ID(SK_HASHENT
)] = META_FUNC(int_sk_hashent
),
553 [META_ID(SK_LINGERTIME
)] = META_FUNC(int_sk_lingertime
),
554 [META_ID(SK_ACK_BACKLOG
)] = META_FUNC(int_sk_ack_bl
),
555 [META_ID(SK_MAX_ACK_BACKLOG
)] = META_FUNC(int_sk_max_ack_bl
),
556 [META_ID(SK_PRIO
)] = META_FUNC(int_sk_prio
),
557 [META_ID(SK_RCVLOWAT
)] = META_FUNC(int_sk_rcvlowat
),
558 [META_ID(SK_RCVTIMEO
)] = META_FUNC(int_sk_rcvtimeo
),
559 [META_ID(SK_SNDTIMEO
)] = META_FUNC(int_sk_sndtimeo
),
560 [META_ID(SK_SENDMSG_OFF
)] = META_FUNC(int_sk_sendmsg_off
),
561 [META_ID(SK_WRITE_PENDING
)] = META_FUNC(int_sk_write_pend
),
565 static inline struct meta_ops
* meta_ops(struct meta_value
*val
)
567 return &__meta_ops
[meta_type(val
)][meta_id(val
)];
570 /**************************************************************************
571 * Type specific operations for TCF_META_TYPE_VAR
572 **************************************************************************/
574 static int meta_var_compare(struct meta_obj
*a
, struct meta_obj
*b
)
576 int r
= a
->len
- b
->len
;
579 r
= memcmp((void *) a
->value
, (void *) b
->value
, a
->len
);
584 static int meta_var_change(struct meta_value
*dst
, struct rtattr
*rta
)
586 int len
= RTA_PAYLOAD(rta
);
588 dst
->val
= (unsigned long) kmalloc(len
, GFP_KERNEL
);
591 memcpy((void *) dst
->val
, RTA_DATA(rta
), len
);
596 static void meta_var_destroy(struct meta_value
*v
)
599 kfree((void *) v
->val
);
602 static void meta_var_apply_extras(struct meta_value
*v
,
603 struct meta_obj
*dst
)
605 int shift
= v
->hdr
.shift
;
607 if (shift
&& shift
< dst
->len
)
611 static int meta_var_dump(struct sk_buff
*skb
, struct meta_value
*v
, int tlv
)
613 if (v
->val
&& v
->len
)
614 RTA_PUT(skb
, tlv
, v
->len
, (void *) v
->val
);
621 /**************************************************************************
622 * Type specific operations for TCF_META_TYPE_INT
623 **************************************************************************/
625 static int meta_int_compare(struct meta_obj
*a
, struct meta_obj
*b
)
627 /* Let gcc optimize it, the unlikely is not really based on
628 * some numbers but jump free code for mismatches seems
630 if (unlikely(a
->value
== b
->value
))
632 else if (a
->value
< b
->value
)
638 static int meta_int_change(struct meta_value
*dst
, struct rtattr
*rta
)
640 if (RTA_PAYLOAD(rta
) >= sizeof(unsigned long)) {
641 dst
->val
= *(unsigned long *) RTA_DATA(rta
);
642 dst
->len
= sizeof(unsigned long);
643 } else if (RTA_PAYLOAD(rta
) == sizeof(u32
)) {
644 dst
->val
= *(u32
*) RTA_DATA(rta
);
645 dst
->len
= sizeof(u32
);
652 static void meta_int_apply_extras(struct meta_value
*v
,
653 struct meta_obj
*dst
)
656 dst
->value
>>= v
->hdr
.shift
;
659 dst
->value
&= v
->val
;
662 static int meta_int_dump(struct sk_buff
*skb
, struct meta_value
*v
, int tlv
)
664 if (v
->len
== sizeof(unsigned long))
665 RTA_PUT(skb
, tlv
, sizeof(unsigned long), &v
->val
);
666 else if (v
->len
== sizeof(u32
)) {
668 RTA_PUT(skb
, tlv
, sizeof(d
), &d
);
677 /**************************************************************************
678 * Type specific operations table
679 **************************************************************************/
683 void (*destroy
)(struct meta_value
*);
684 int (*compare
)(struct meta_obj
*, struct meta_obj
*);
685 int (*change
)(struct meta_value
*, struct rtattr
*);
686 void (*apply_extras
)(struct meta_value
*, struct meta_obj
*);
687 int (*dump
)(struct sk_buff
*, struct meta_value
*, int);
690 static struct meta_type_ops __meta_type_ops
[TCF_META_TYPE_MAX
+1] = {
691 [TCF_META_TYPE_VAR
] = {
692 .destroy
= meta_var_destroy
,
693 .compare
= meta_var_compare
,
694 .change
= meta_var_change
,
695 .apply_extras
= meta_var_apply_extras
,
696 .dump
= meta_var_dump
698 [TCF_META_TYPE_INT
] = {
699 .compare
= meta_int_compare
,
700 .change
= meta_int_change
,
701 .apply_extras
= meta_int_apply_extras
,
702 .dump
= meta_int_dump
706 static inline struct meta_type_ops
* meta_type_ops(struct meta_value
*v
)
708 return &__meta_type_ops
[meta_type(v
)];
711 /**************************************************************************
713 **************************************************************************/
715 static inline int meta_get(struct sk_buff
*skb
, struct tcf_pkt_info
*info
,
716 struct meta_value
*v
, struct meta_obj
*dst
)
720 if (meta_id(v
) == TCF_META_ID_VALUE
) {
726 meta_ops(v
)->get(skb
, info
, v
, dst
, &err
);
730 if (meta_type_ops(v
)->apply_extras
)
731 meta_type_ops(v
)->apply_extras(v
, dst
);
736 static int em_meta_match(struct sk_buff
*skb
, struct tcf_ematch
*m
,
737 struct tcf_pkt_info
*info
)
740 struct meta_match
*meta
= (struct meta_match
*) m
->data
;
741 struct meta_obj l_value
, r_value
;
743 if (meta_get(skb
, info
, &meta
->lvalue
, &l_value
) < 0 ||
744 meta_get(skb
, info
, &meta
->rvalue
, &r_value
) < 0)
747 r
= meta_type_ops(&meta
->lvalue
)->compare(&l_value
, &r_value
);
749 switch (meta
->lvalue
.hdr
.op
) {
761 static inline void meta_delete(struct meta_match
*meta
)
763 struct meta_type_ops
*ops
= meta_type_ops(&meta
->lvalue
);
765 if (ops
&& ops
->destroy
) {
766 ops
->destroy(&meta
->lvalue
);
767 ops
->destroy(&meta
->rvalue
);
773 static inline int meta_change_data(struct meta_value
*dst
, struct rtattr
*rta
)
776 if (RTA_PAYLOAD(rta
) == 0)
779 return meta_type_ops(dst
)->change(dst
, rta
);
785 static inline int meta_is_supported(struct meta_value
*val
)
787 return (!meta_id(val
) || meta_ops(val
)->get
);
790 static int em_meta_change(struct tcf_proto
*tp
, void *data
, int len
,
791 struct tcf_ematch
*m
)
794 struct rtattr
*tb
[TCA_EM_META_MAX
];
795 struct tcf_meta_hdr
*hdr
;
796 struct meta_match
*meta
= NULL
;
798 if (rtattr_parse(tb
, TCA_EM_META_MAX
, data
, len
) < 0)
801 if (tb
[TCA_EM_META_HDR
-1] == NULL
||
802 RTA_PAYLOAD(tb
[TCA_EM_META_HDR
-1]) < sizeof(*hdr
))
804 hdr
= RTA_DATA(tb
[TCA_EM_META_HDR
-1]);
806 if (TCF_META_TYPE(hdr
->left
.kind
) != TCF_META_TYPE(hdr
->right
.kind
) ||
807 TCF_META_TYPE(hdr
->left
.kind
) > TCF_META_TYPE_MAX
||
808 TCF_META_ID(hdr
->left
.kind
) > TCF_META_ID_MAX
||
809 TCF_META_ID(hdr
->right
.kind
) > TCF_META_ID_MAX
)
812 meta
= kmalloc(sizeof(*meta
), GFP_KERNEL
);
815 memset(meta
, 0, sizeof(*meta
));
817 memcpy(&meta
->lvalue
.hdr
, &hdr
->left
, sizeof(hdr
->left
));
818 memcpy(&meta
->rvalue
.hdr
, &hdr
->right
, sizeof(hdr
->right
));
820 if (!meta_is_supported(&meta
->lvalue
) ||
821 !meta_is_supported(&meta
->rvalue
)) {
826 if (meta_change_data(&meta
->lvalue
, tb
[TCA_EM_META_LVALUE
-1]) < 0 ||
827 meta_change_data(&meta
->rvalue
, tb
[TCA_EM_META_RVALUE
-1]) < 0)
830 m
->datalen
= sizeof(*meta
);
831 m
->data
= (unsigned long) meta
;
840 static void em_meta_destroy(struct tcf_proto
*tp
, struct tcf_ematch
*m
)
843 meta_delete((struct meta_match
*) m
->data
);
846 static int em_meta_dump(struct sk_buff
*skb
, struct tcf_ematch
*em
)
848 struct meta_match
*meta
= (struct meta_match
*) em
->data
;
849 struct tcf_meta_hdr hdr
;
850 struct meta_type_ops
*ops
;
852 memset(&hdr
, 0, sizeof(hdr
));
853 memcpy(&hdr
.left
, &meta
->lvalue
.hdr
, sizeof(hdr
.left
));
854 memcpy(&hdr
.right
, &meta
->rvalue
.hdr
, sizeof(hdr
.right
));
856 RTA_PUT(skb
, TCA_EM_META_HDR
, sizeof(hdr
), &hdr
);
858 ops
= meta_type_ops(&meta
->lvalue
);
859 if (ops
->dump(skb
, &meta
->lvalue
, TCA_EM_META_LVALUE
) < 0 ||
860 ops
->dump(skb
, &meta
->rvalue
, TCA_EM_META_RVALUE
) < 0)
869 static struct tcf_ematch_ops em_meta_ops
= {
871 .change
= em_meta_change
,
872 .match
= em_meta_match
,
873 .destroy
= em_meta_destroy
,
874 .dump
= em_meta_dump
,
875 .owner
= THIS_MODULE
,
876 .link
= LIST_HEAD_INIT(em_meta_ops
.link
)
879 static int __init
init_em_meta(void)
881 return tcf_em_register(&em_meta_ops
);
884 static void __exit
exit_em_meta(void)
886 tcf_em_unregister(&em_meta_ops
);
889 MODULE_LICENSE("GPL");
891 module_init(init_em_meta
);
892 module_exit(exit_em_meta
);