em_meta.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * net/sched/em_meta.c Metadata ematch
  4. *
  5. * Authors: Thomas Graf <tgraf@suug.ch>
  6. *
  7. * ==========================================================================
  8. *
  9. * The metadata ematch compares two meta objects where each object
  10. * represents either a meta value stored in the kernel or a static
  11. * value provided by userspace. The objects are not provided by
  12. * userspace itself but rather a definition providing the information
  13. * to build them. Every object is of a certain type which must be
  14. * equal to the object it is being compared to.
  15. *
  16. * The definition of a objects conists of the type (meta type), a
  17. * identifier (meta id) and additional type specific information.
  18. * The meta id is either TCF_META_TYPE_VALUE for values provided by
  19. * userspace or a index to the meta operations table consisting of
  20. * function pointers to type specific meta data collectors returning
  21. * the value of the requested meta value.
  22. *
  23. * lvalue rvalue
  24. * +-----------+ +-----------+
  25. * | type: INT | | type: INT |
  26. * def | id: DEV | | id: VALUE |
  27. * | data: | | data: 3 |
  28. * +-----------+ +-----------+
  29. * | |
  30. * ---> meta_ops[INT][DEV](...) |
  31. * | |
  32. * ----------- |
  33. * V V
  34. * +-----------+ +-----------+
  35. * | type: INT | | type: INT |
  36. * obj | id: DEV | | id: VALUE |
  37. * | data: 2 |<--data got filled out | data: 3 |
  38. * +-----------+ +-----------+
  39. * | |
  40. * --------------> 2 equals 3 <--------------
  41. *
  42. * This is a simplified schema, the complexity varies depending
  43. * on the meta type. Obviously, the length of the data must also
  44. * be provided for non-numeric types.
  45. *
  46. * Additionally, type dependent modifiers such as shift operators
  47. * or mask may be applied to extend the functionaliy. As of now,
  48. * the variable length type supports shifting the byte string to
  49. * the right, eating up any number of octets and thus supporting
  50. * wildcard interface name comparisons such as "ppp%" matching
  51. * ppp0..9.
  52. *
  53. * NOTE: Certain meta values depend on other subsystems and are
  54. * only available if that subsystem is enabled in the kernel.
  55. */
  56. #include <linux/slab.h>
  57. #include <linux/module.h>
  58. #include <linux/types.h>
  59. #include <linux/kernel.h>
  60. #include <linux/sched.h>
  61. #include <linux/sched/loadavg.h>
  62. #include <linux/string.h>
  63. #include <linux/skbuff.h>
  64. #include <linux/random.h>
  65. #include <linux/if_vlan.h>
  66. #include <linux/tc_ematch/tc_em_meta.h>
  67. #include <net/dst.h>
  68. #include <net/route.h>
  69. #include <net/pkt_cls.h>
  70. #include <net/sock.h>
  71. struct meta_obj {
  72. unsigned long value;
  73. unsigned int len;
  74. };
  75. struct meta_value {
  76. struct tcf_meta_val hdr;
  77. unsigned long val;
  78. unsigned int len;
  79. };
  80. struct meta_match {
  81. struct meta_value lvalue;
  82. struct meta_value rvalue;
  83. };
  84. static inline int meta_id(struct meta_value *v)
  85. {
  86. return TCF_META_ID(v->hdr.kind);
  87. }
  88. static inline int meta_type(struct meta_value *v)
  89. {
  90. return TCF_META_TYPE(v->hdr.kind);
  91. }
  92. #define META_COLLECTOR(FUNC) static void meta_##FUNC(struct sk_buff *skb, \
  93. struct tcf_pkt_info *info, struct meta_value *v, \
  94. struct meta_obj *dst, int *err)
  95. /**************************************************************************
  96. * System status & misc
  97. **************************************************************************/
  98. META_COLLECTOR(int_random)
  99. {
  100. get_random_bytes(&dst->value, sizeof(dst->value));
  101. }
  102. static inline unsigned long fixed_loadavg(int load)
  103. {
  104. int rnd_load = load + (FIXED_1/200);
  105. int rnd_frac = ((rnd_load & (FIXED_1-1)) * 100) >> FSHIFT;
  106. return ((rnd_load >> FSHIFT) * 100) + rnd_frac;
  107. }
  108. META_COLLECTOR(int_loadavg_0)
  109. {
  110. dst->value = fixed_loadavg(avenrun[0]);
  111. }
  112. META_COLLECTOR(int_loadavg_1)
  113. {
  114. dst->value = fixed_loadavg(avenrun[1]);
  115. }
  116. META_COLLECTOR(int_loadavg_2)
  117. {
  118. dst->value = fixed_loadavg(avenrun[2]);
  119. }
  120. /**************************************************************************
  121. * Device names & indices
  122. **************************************************************************/
  123. static inline int int_dev(struct net_device *dev, struct meta_obj *dst)
  124. {
  125. if (unlikely(dev == NULL))
  126. return -1;
  127. dst->value = dev->ifindex;
  128. return 0;
  129. }
  130. static inline int var_dev(struct net_device *dev, struct meta_obj *dst)
  131. {
  132. if (unlikely(dev == NULL))
  133. return -1;
  134. dst->value = (unsigned long) dev->name;
  135. dst->len = strlen(dev->name);
  136. return 0;
  137. }
  138. META_COLLECTOR(int_dev)
  139. {
  140. *err = int_dev(skb->dev, dst);
  141. }
  142. META_COLLECTOR(var_dev)
  143. {
  144. *err = var_dev(skb->dev, dst);
  145. }
  146. /**************************************************************************
  147. * vlan tag
  148. **************************************************************************/
  149. META_COLLECTOR(int_vlan_tag)
  150. {
  151. unsigned short tag;
  152. if (skb_vlan_tag_present(skb))
  153. dst->value = skb_vlan_tag_get(skb);
  154. else if (!__vlan_get_tag(skb, &tag))
  155. dst->value = tag;
  156. else
  157. *err = -1;
  158. }
  159. /**************************************************************************
  160. * skb attributes
  161. **************************************************************************/
  162. META_COLLECTOR(int_priority)
  163. {
  164. dst->value = skb->priority;
  165. }
  166. META_COLLECTOR(int_protocol)
  167. {
  168. /* Let userspace take care of the byte ordering */
  169. dst->value = skb_protocol(skb, false);
  170. }
  171. META_COLLECTOR(int_pkttype)
  172. {
  173. dst->value = skb->pkt_type;
  174. }
  175. META_COLLECTOR(int_pktlen)
  176. {
  177. dst->value = skb->len;
  178. }
  179. META_COLLECTOR(int_datalen)
  180. {
  181. dst->value = skb->data_len;
  182. }
  183. META_COLLECTOR(int_maclen)
  184. {
  185. dst->value = skb->mac_len;
  186. }
  187. META_COLLECTOR(int_rxhash)
  188. {
  189. dst->value = skb_get_hash(skb);
  190. }
  191. /**************************************************************************
  192. * Netfilter
  193. **************************************************************************/
  194. META_COLLECTOR(int_mark)
  195. {
  196. dst->value = skb->mark;
  197. }
  198. /**************************************************************************
  199. * Traffic Control
  200. **************************************************************************/
  201. META_COLLECTOR(int_tcindex)
  202. {
  203. dst->value = skb->tc_index;
  204. }
  205. /**************************************************************************
  206. * Routing
  207. **************************************************************************/
  208. META_COLLECTOR(int_rtclassid)
  209. {
  210. if (unlikely(skb_dst(skb) == NULL))
  211. *err = -1;
  212. else
  213. #ifdef CONFIG_IP_ROUTE_CLASSID
  214. dst->value = skb_dst(skb)->tclassid;
  215. #else
  216. dst->value = 0;
  217. #endif
  218. }
  219. META_COLLECTOR(int_rtiif)
  220. {
  221. if (unlikely(skb_rtable(skb) == NULL))
  222. *err = -1;
  223. else
  224. dst->value = inet_iif(skb);
  225. }
  226. /**************************************************************************
  227. * Socket Attributes
  228. **************************************************************************/
  229. #define skip_nonlocal(skb) \
  230. (unlikely(skb->sk == NULL))
  231. META_COLLECTOR(int_sk_family)
  232. {
  233. if (skip_nonlocal(skb)) {
  234. *err = -1;
  235. return;
  236. }
  237. dst->value = skb->sk->sk_family;
  238. }
  239. META_COLLECTOR(int_sk_state)
  240. {
  241. if (skip_nonlocal(skb)) {
  242. *err = -1;
  243. return;
  244. }
  245. dst->value = skb->sk->sk_state;
  246. }
  247. META_COLLECTOR(int_sk_reuse)
  248. {
  249. if (skip_nonlocal(skb)) {
  250. *err = -1;
  251. return;
  252. }
  253. dst->value = skb->sk->sk_reuse;
  254. }
  255. META_COLLECTOR(int_sk_bound_if)
  256. {
  257. if (skip_nonlocal(skb)) {
  258. *err = -1;
  259. return;
  260. }
  261. /* No error if bound_dev_if is 0, legal userspace check */
  262. dst->value = skb->sk->sk_bound_dev_if;
  263. }
  264. META_COLLECTOR(var_sk_bound_if)
  265. {
  266. if (skip_nonlocal(skb)) {
  267. *err = -1;
  268. return;
  269. }
  270. if (skb->sk->sk_bound_dev_if == 0) {
  271. dst->value = (unsigned long) "any";
  272. dst->len = 3;
  273. } else {
  274. struct net_device *dev;
  275. rcu_read_lock();
  276. dev = dev_get_by_index_rcu(sock_net(skb->sk),
  277. skb->sk->sk_bound_dev_if);
  278. *err = var_dev(dev, dst);
  279. rcu_read_unlock();
  280. }
  281. }
  282. META_COLLECTOR(int_sk_refcnt)
  283. {
  284. if (skip_nonlocal(skb)) {
  285. *err = -1;
  286. return;
  287. }
  288. dst->value = refcount_read(&skb->sk->sk_refcnt);
  289. }
  290. META_COLLECTOR(int_sk_rcvbuf)
  291. {
  292. const struct sock *sk = skb_to_full_sk(skb);
  293. if (!sk) {
  294. *err = -1;
  295. return;
  296. }
  297. dst->value = sk->sk_rcvbuf;
  298. }
  299. META_COLLECTOR(int_sk_shutdown)
  300. {
  301. const struct sock *sk = skb_to_full_sk(skb);
  302. if (!sk) {
  303. *err = -1;
  304. return;
  305. }
  306. dst->value = sk->sk_shutdown;
  307. }
  308. META_COLLECTOR(int_sk_proto)
  309. {
  310. const struct sock *sk = skb_to_full_sk(skb);
  311. if (!sk) {
  312. *err = -1;
  313. return;
  314. }
  315. dst->value = sk->sk_protocol;
  316. }
  317. META_COLLECTOR(int_sk_type)
  318. {
  319. const struct sock *sk = skb_to_full_sk(skb);
  320. if (!sk) {
  321. *err = -1;
  322. return;
  323. }
  324. dst->value = sk->sk_type;
  325. }
  326. META_COLLECTOR(int_sk_rmem_alloc)
  327. {
  328. const struct sock *sk = skb_to_full_sk(skb);
  329. if (!sk) {
  330. *err = -1;
  331. return;
  332. }
  333. dst->value = sk_rmem_alloc_get(sk);
  334. }
  335. META_COLLECTOR(int_sk_wmem_alloc)
  336. {
  337. const struct sock *sk = skb_to_full_sk(skb);
  338. if (!sk) {
  339. *err = -1;
  340. return;
  341. }
  342. dst->value = sk_wmem_alloc_get(sk);
  343. }
  344. META_COLLECTOR(int_sk_omem_alloc)
  345. {
  346. const struct sock *sk = skb_to_full_sk(skb);
  347. if (!sk) {
  348. *err = -1;
  349. return;
  350. }
  351. dst->value = atomic_read(&sk->sk_omem_alloc);
  352. }
  353. META_COLLECTOR(int_sk_rcv_qlen)
  354. {
  355. const struct sock *sk = skb_to_full_sk(skb);
  356. if (!sk) {
  357. *err = -1;
  358. return;
  359. }
  360. dst->value = sk->sk_receive_queue.qlen;
  361. }
  362. META_COLLECTOR(int_sk_snd_qlen)
  363. {
  364. const struct sock *sk = skb_to_full_sk(skb);
  365. if (!sk) {
  366. *err = -1;
  367. return;
  368. }
  369. dst->value = sk->sk_write_queue.qlen;
  370. }
  371. META_COLLECTOR(int_sk_wmem_queued)
  372. {
  373. const struct sock *sk = skb_to_full_sk(skb);
  374. if (!sk) {
  375. *err = -1;
  376. return;
  377. }
  378. dst->value = READ_ONCE(sk->sk_wmem_queued);
  379. }
  380. META_COLLECTOR(int_sk_fwd_alloc)
  381. {
  382. const struct sock *sk = skb_to_full_sk(skb);
  383. if (!sk) {
  384. *err = -1;
  385. return;
  386. }
  387. dst->value = sk->sk_forward_alloc;
  388. }
  389. META_COLLECTOR(int_sk_sndbuf)
  390. {
  391. const struct sock *sk = skb_to_full_sk(skb);
  392. if (!sk) {
  393. *err = -1;
  394. return;
  395. }
  396. dst->value = sk->sk_sndbuf;
  397. }
  398. META_COLLECTOR(int_sk_alloc)
  399. {
  400. const struct sock *sk = skb_to_full_sk(skb);
  401. if (!sk) {
  402. *err = -1;
  403. return;
  404. }
  405. dst->value = (__force int) sk->sk_allocation;
  406. }
  407. META_COLLECTOR(int_sk_hash)
  408. {
  409. if (skip_nonlocal(skb)) {
  410. *err = -1;
  411. return;
  412. }
  413. dst->value = skb->sk->sk_hash;
  414. }
  415. META_COLLECTOR(int_sk_lingertime)
  416. {
  417. const struct sock *sk = skb_to_full_sk(skb);
  418. if (!sk) {
  419. *err = -1;
  420. return;
  421. }
  422. dst->value = sk->sk_lingertime / HZ;
  423. }
  424. META_COLLECTOR(int_sk_err_qlen)
  425. {
  426. const struct sock *sk = skb_to_full_sk(skb);
  427. if (!sk) {
  428. *err = -1;
  429. return;
  430. }
  431. dst->value = sk->sk_error_queue.qlen;
  432. }
  433. META_COLLECTOR(int_sk_ack_bl)
  434. {
  435. const struct sock *sk = skb_to_full_sk(skb);
  436. if (!sk) {
  437. *err = -1;
  438. return;
  439. }
  440. dst->value = READ_ONCE(sk->sk_ack_backlog);
  441. }
  442. META_COLLECTOR(int_sk_max_ack_bl)
  443. {
  444. const struct sock *sk = skb_to_full_sk(skb);
  445. if (!sk) {
  446. *err = -1;
  447. return;
  448. }
  449. dst->value = READ_ONCE(sk->sk_max_ack_backlog);
  450. }
  451. META_COLLECTOR(int_sk_prio)
  452. {
  453. const struct sock *sk = skb_to_full_sk(skb);
  454. if (!sk) {
  455. *err = -1;
  456. return;
  457. }
  458. dst->value = sk->sk_priority;
  459. }
  460. META_COLLECTOR(int_sk_rcvlowat)
  461. {
  462. const struct sock *sk = skb_to_full_sk(skb);
  463. if (!sk) {
  464. *err = -1;
  465. return;
  466. }
  467. dst->value = READ_ONCE(sk->sk_rcvlowat);
  468. }
  469. META_COLLECTOR(int_sk_rcvtimeo)
  470. {
  471. const struct sock *sk = skb_to_full_sk(skb);
  472. if (!sk) {
  473. *err = -1;
  474. return;
  475. }
  476. dst->value = sk->sk_rcvtimeo / HZ;
  477. }
  478. META_COLLECTOR(int_sk_sndtimeo)
  479. {
  480. const struct sock *sk = skb_to_full_sk(skb);
  481. if (!sk) {
  482. *err = -1;
  483. return;
  484. }
  485. dst->value = sk->sk_sndtimeo / HZ;
  486. }
  487. META_COLLECTOR(int_sk_sendmsg_off)
  488. {
  489. const struct sock *sk = skb_to_full_sk(skb);
  490. if (!sk) {
  491. *err = -1;
  492. return;
  493. }
  494. dst->value = sk->sk_frag.offset;
  495. }
  496. META_COLLECTOR(int_sk_write_pend)
  497. {
  498. const struct sock *sk = skb_to_full_sk(skb);
  499. if (!sk) {
  500. *err = -1;
  501. return;
  502. }
  503. dst->value = sk->sk_write_pending;
  504. }
  505. /**************************************************************************
  506. * Meta value collectors assignment table
  507. **************************************************************************/
  508. struct meta_ops {
  509. void (*get)(struct sk_buff *, struct tcf_pkt_info *,
  510. struct meta_value *, struct meta_obj *, int *);
  511. };
  512. #define META_ID(name) TCF_META_ID_##name
  513. #define META_FUNC(name) { .get = meta_##name }
  514. /* Meta value operations table listing all meta value collectors and
  515. * assigns them to a type and meta id. */
  516. static struct meta_ops __meta_ops[TCF_META_TYPE_MAX + 1][TCF_META_ID_MAX + 1] = {
  517. [TCF_META_TYPE_VAR] = {
  518. [META_ID(DEV)] = META_FUNC(var_dev),
  519. [META_ID(SK_BOUND_IF)] = META_FUNC(var_sk_bound_if),
  520. },
  521. [TCF_META_TYPE_INT] = {
  522. [META_ID(RANDOM)] = META_FUNC(int_random),
  523. [META_ID(LOADAVG_0)] = META_FUNC(int_loadavg_0),
  524. [META_ID(LOADAVG_1)] = META_FUNC(int_loadavg_1),
  525. [META_ID(LOADAVG_2)] = META_FUNC(int_loadavg_2),
  526. [META_ID(DEV)] = META_FUNC(int_dev),
  527. [META_ID(PRIORITY)] = META_FUNC(int_priority),
  528. [META_ID(PROTOCOL)] = META_FUNC(int_protocol),
  529. [META_ID(PKTTYPE)] = META_FUNC(int_pkttype),
  530. [META_ID(PKTLEN)] = META_FUNC(int_pktlen),
  531. [META_ID(DATALEN)] = META_FUNC(int_datalen),
  532. [META_ID(MACLEN)] = META_FUNC(int_maclen),
  533. [META_ID(NFMARK)] = META_FUNC(int_mark),
  534. [META_ID(TCINDEX)] = META_FUNC(int_tcindex),
  535. [META_ID(RTCLASSID)] = META_FUNC(int_rtclassid),
  536. [META_ID(RTIIF)] = META_FUNC(int_rtiif),
  537. [META_ID(SK_FAMILY)] = META_FUNC(int_sk_family),
  538. [META_ID(SK_STATE)] = META_FUNC(int_sk_state),
  539. [META_ID(SK_REUSE)] = META_FUNC(int_sk_reuse),
  540. [META_ID(SK_BOUND_IF)] = META_FUNC(int_sk_bound_if),
  541. [META_ID(SK_REFCNT)] = META_FUNC(int_sk_refcnt),
  542. [META_ID(SK_RCVBUF)] = META_FUNC(int_sk_rcvbuf),
  543. [META_ID(SK_SNDBUF)] = META_FUNC(int_sk_sndbuf),
  544. [META_ID(SK_SHUTDOWN)] = META_FUNC(int_sk_shutdown),
  545. [META_ID(SK_PROTO)] = META_FUNC(int_sk_proto),
  546. [META_ID(SK_TYPE)] = META_FUNC(int_sk_type),
  547. [META_ID(SK_RMEM_ALLOC)] = META_FUNC(int_sk_rmem_alloc),
  548. [META_ID(SK_WMEM_ALLOC)] = META_FUNC(int_sk_wmem_alloc),
  549. [META_ID(SK_OMEM_ALLOC)] = META_FUNC(int_sk_omem_alloc),
  550. [META_ID(SK_WMEM_QUEUED)] = META_FUNC(int_sk_wmem_queued),
  551. [META_ID(SK_RCV_QLEN)] = META_FUNC(int_sk_rcv_qlen),
  552. [META_ID(SK_SND_QLEN)] = META_FUNC(int_sk_snd_qlen),
  553. [META_ID(SK_ERR_QLEN)] = META_FUNC(int_sk_err_qlen),
  554. [META_ID(SK_FORWARD_ALLOCS)] = META_FUNC(int_sk_fwd_alloc),
  555. [META_ID(SK_ALLOCS)] = META_FUNC(int_sk_alloc),
  556. [META_ID(SK_HASH)] = META_FUNC(int_sk_hash),
  557. [META_ID(SK_LINGERTIME)] = META_FUNC(int_sk_lingertime),
  558. [META_ID(SK_ACK_BACKLOG)] = META_FUNC(int_sk_ack_bl),
  559. [META_ID(SK_MAX_ACK_BACKLOG)] = META_FUNC(int_sk_max_ack_bl),
  560. [META_ID(SK_PRIO)] = META_FUNC(int_sk_prio),
  561. [META_ID(SK_RCVLOWAT)] = META_FUNC(int_sk_rcvlowat),
  562. [META_ID(SK_RCVTIMEO)] = META_FUNC(int_sk_rcvtimeo),
  563. [META_ID(SK_SNDTIMEO)] = META_FUNC(int_sk_sndtimeo),
  564. [META_ID(SK_SENDMSG_OFF)] = META_FUNC(int_sk_sendmsg_off),
  565. [META_ID(SK_WRITE_PENDING)] = META_FUNC(int_sk_write_pend),
  566. [META_ID(VLAN_TAG)] = META_FUNC(int_vlan_tag),
  567. [META_ID(RXHASH)] = META_FUNC(int_rxhash),
  568. }
  569. };
  570. static inline struct meta_ops *meta_ops(struct meta_value *val)
  571. {
  572. return &__meta_ops[meta_type(val)][meta_id(val)];
  573. }
  574. /**************************************************************************
  575. * Type specific operations for TCF_META_TYPE_VAR
  576. **************************************************************************/
  577. static int meta_var_compare(struct meta_obj *a, struct meta_obj *b)
  578. {
  579. int r = a->len - b->len;
  580. if (r == 0)
  581. r = memcmp((void *) a->value, (void *) b->value, a->len);
  582. return r;
  583. }
  584. static int meta_var_change(struct meta_value *dst, struct nlattr *nla)
  585. {
  586. int len = nla_len(nla);
  587. dst->val = (unsigned long)kmemdup(nla_data(nla), len, GFP_KERNEL);
  588. if (dst->val == 0UL)
  589. return -ENOMEM;
  590. dst->len = len;
  591. return 0;
  592. }
  593. static void meta_var_destroy(struct meta_value *v)
  594. {
  595. kfree((void *) v->val);
  596. }
  597. static void meta_var_apply_extras(struct meta_value *v,
  598. struct meta_obj *dst)
  599. {
  600. int shift = v->hdr.shift;
  601. if (shift && shift < dst->len)
  602. dst->len -= shift;
  603. }
  604. static int meta_var_dump(struct sk_buff *skb, struct meta_value *v, int tlv)
  605. {
  606. if (v->val && v->len &&
  607. nla_put(skb, tlv, v->len, (void *) v->val))
  608. goto nla_put_failure;
  609. return 0;
  610. nla_put_failure:
  611. return -1;
  612. }
  613. /**************************************************************************
  614. * Type specific operations for TCF_META_TYPE_INT
  615. **************************************************************************/
  616. static int meta_int_compare(struct meta_obj *a, struct meta_obj *b)
  617. {
  618. /* Let gcc optimize it, the unlikely is not really based on
  619. * some numbers but jump free code for mismatches seems
  620. * more logical. */
  621. if (unlikely(a->value == b->value))
  622. return 0;
  623. else if (a->value < b->value)
  624. return -1;
  625. else
  626. return 1;
  627. }
  628. static int meta_int_change(struct meta_value *dst, struct nlattr *nla)
  629. {
  630. if (nla_len(nla) >= sizeof(unsigned long)) {
  631. dst->val = *(unsigned long *) nla_data(nla);
  632. dst->len = sizeof(unsigned long);
  633. } else if (nla_len(nla) == sizeof(u32)) {
  634. dst->val = nla_get_u32(nla);
  635. dst->len = sizeof(u32);
  636. } else
  637. return -EINVAL;
  638. return 0;
  639. }
  640. static void meta_int_apply_extras(struct meta_value *v,
  641. struct meta_obj *dst)
  642. {
  643. if (v->hdr.shift)
  644. dst->value >>= v->hdr.shift;
  645. if (v->val)
  646. dst->value &= v->val;
  647. }
  648. static int meta_int_dump(struct sk_buff *skb, struct meta_value *v, int tlv)
  649. {
  650. if (v->len == sizeof(unsigned long)) {
  651. if (nla_put(skb, tlv, sizeof(unsigned long), &v->val))
  652. goto nla_put_failure;
  653. } else if (v->len == sizeof(u32)) {
  654. if (nla_put_u32(skb, tlv, v->val))
  655. goto nla_put_failure;
  656. }
  657. return 0;
  658. nla_put_failure:
  659. return -1;
  660. }
  661. /**************************************************************************
  662. * Type specific operations table
  663. **************************************************************************/
  664. struct meta_type_ops {
  665. void (*destroy)(struct meta_value *);
  666. int (*compare)(struct meta_obj *, struct meta_obj *);
  667. int (*change)(struct meta_value *, struct nlattr *);
  668. void (*apply_extras)(struct meta_value *, struct meta_obj *);
  669. int (*dump)(struct sk_buff *, struct meta_value *, int);
  670. };
  671. static const struct meta_type_ops __meta_type_ops[TCF_META_TYPE_MAX + 1] = {
  672. [TCF_META_TYPE_VAR] = {
  673. .destroy = meta_var_destroy,
  674. .compare = meta_var_compare,
  675. .change = meta_var_change,
  676. .apply_extras = meta_var_apply_extras,
  677. .dump = meta_var_dump
  678. },
  679. [TCF_META_TYPE_INT] = {
  680. .compare = meta_int_compare,
  681. .change = meta_int_change,
  682. .apply_extras = meta_int_apply_extras,
  683. .dump = meta_int_dump
  684. }
  685. };
  686. static inline const struct meta_type_ops *meta_type_ops(struct meta_value *v)
  687. {
  688. return &__meta_type_ops[meta_type(v)];
  689. }
  690. /**************************************************************************
  691. * Core
  692. **************************************************************************/
  693. static int meta_get(struct sk_buff *skb, struct tcf_pkt_info *info,
  694. struct meta_value *v, struct meta_obj *dst)
  695. {
  696. int err = 0;
  697. if (meta_id(v) == TCF_META_ID_VALUE) {
  698. dst->value = v->val;
  699. dst->len = v->len;
  700. return 0;
  701. }
  702. meta_ops(v)->get(skb, info, v, dst, &err);
  703. if (err < 0)
  704. return err;
  705. if (meta_type_ops(v)->apply_extras)
  706. meta_type_ops(v)->apply_extras(v, dst);
  707. return 0;
  708. }
  709. static int em_meta_match(struct sk_buff *skb, struct tcf_ematch *m,
  710. struct tcf_pkt_info *info)
  711. {
  712. int r;
  713. struct meta_match *meta = (struct meta_match *) m->data;
  714. struct meta_obj l_value, r_value;
  715. if (meta_get(skb, info, &meta->lvalue, &l_value) < 0 ||
  716. meta_get(skb, info, &meta->rvalue, &r_value) < 0)
  717. return 0;
  718. r = meta_type_ops(&meta->lvalue)->compare(&l_value, &r_value);
  719. switch (meta->lvalue.hdr.op) {
  720. case TCF_EM_OPND_EQ:
  721. return !r;
  722. case TCF_EM_OPND_LT:
  723. return r < 0;
  724. case TCF_EM_OPND_GT:
  725. return r > 0;
  726. }
  727. return 0;
  728. }
  729. static void meta_delete(struct meta_match *meta)
  730. {
  731. if (meta) {
  732. const struct meta_type_ops *ops = meta_type_ops(&meta->lvalue);
  733. if (ops && ops->destroy) {
  734. ops->destroy(&meta->lvalue);
  735. ops->destroy(&meta->rvalue);
  736. }
  737. }
  738. kfree(meta);
  739. }
  740. static inline int meta_change_data(struct meta_value *dst, struct nlattr *nla)
  741. {
  742. if (nla) {
  743. if (nla_len(nla) == 0)
  744. return -EINVAL;
  745. return meta_type_ops(dst)->change(dst, nla);
  746. }
  747. return 0;
  748. }
  749. static inline int meta_is_supported(struct meta_value *val)
  750. {
  751. return !meta_id(val) || meta_ops(val)->get;
  752. }
  753. static const struct nla_policy meta_policy[TCA_EM_META_MAX + 1] = {
  754. [TCA_EM_META_HDR] = { .len = sizeof(struct tcf_meta_hdr) },
  755. };
  756. static int em_meta_change(struct net *net, void *data, int len,
  757. struct tcf_ematch *m)
  758. {
  759. int err;
  760. struct nlattr *tb[TCA_EM_META_MAX + 1];
  761. struct tcf_meta_hdr *hdr;
  762. struct meta_match *meta = NULL;
  763. err = nla_parse_deprecated(tb, TCA_EM_META_MAX, data, len,
  764. meta_policy, NULL);
  765. if (err < 0)
  766. goto errout;
  767. err = -EINVAL;
  768. if (tb[TCA_EM_META_HDR] == NULL)
  769. goto errout;
  770. hdr = nla_data(tb[TCA_EM_META_HDR]);
  771. if (TCF_META_TYPE(hdr->left.kind) != TCF_META_TYPE(hdr->right.kind) ||
  772. TCF_META_TYPE(hdr->left.kind) > TCF_META_TYPE_MAX ||
  773. TCF_META_ID(hdr->left.kind) > TCF_META_ID_MAX ||
  774. TCF_META_ID(hdr->right.kind) > TCF_META_ID_MAX)
  775. goto errout;
  776. meta = kzalloc(sizeof(*meta), GFP_KERNEL);
  777. if (meta == NULL) {
  778. err = -ENOMEM;
  779. goto errout;
  780. }
  781. memcpy(&meta->lvalue.hdr, &hdr->left, sizeof(hdr->left));
  782. memcpy(&meta->rvalue.hdr, &hdr->right, sizeof(hdr->right));
  783. if (!meta_is_supported(&meta->lvalue) ||
  784. !meta_is_supported(&meta->rvalue)) {
  785. err = -EOPNOTSUPP;
  786. goto errout;
  787. }
  788. if (meta_change_data(&meta->lvalue, tb[TCA_EM_META_LVALUE]) < 0 ||
  789. meta_change_data(&meta->rvalue, tb[TCA_EM_META_RVALUE]) < 0)
  790. goto errout;
  791. m->datalen = sizeof(*meta);
  792. m->data = (unsigned long) meta;
  793. err = 0;
  794. errout:
  795. if (err && meta)
  796. meta_delete(meta);
  797. return err;
  798. }
  799. static void em_meta_destroy(struct tcf_ematch *m)
  800. {
  801. if (m)
  802. meta_delete((struct meta_match *) m->data);
  803. }
  804. static int em_meta_dump(struct sk_buff *skb, struct tcf_ematch *em)
  805. {
  806. struct meta_match *meta = (struct meta_match *) em->data;
  807. struct tcf_meta_hdr hdr;
  808. const struct meta_type_ops *ops;
  809. memset(&hdr, 0, sizeof(hdr));
  810. memcpy(&hdr.left, &meta->lvalue.hdr, sizeof(hdr.left));
  811. memcpy(&hdr.right, &meta->rvalue.hdr, sizeof(hdr.right));
  812. if (nla_put(skb, TCA_EM_META_HDR, sizeof(hdr), &hdr))
  813. goto nla_put_failure;
  814. ops = meta_type_ops(&meta->lvalue);
  815. if (ops->dump(skb, &meta->lvalue, TCA_EM_META_LVALUE) < 0 ||
  816. ops->dump(skb, &meta->rvalue, TCA_EM_META_RVALUE) < 0)
  817. goto nla_put_failure;
  818. return 0;
  819. nla_put_failure:
  820. return -1;
  821. }
  822. static struct tcf_ematch_ops em_meta_ops = {
  823. .kind = TCF_EM_META,
  824. .change = em_meta_change,
  825. .match = em_meta_match,
  826. .destroy = em_meta_destroy,
  827. .dump = em_meta_dump,
  828. .owner = THIS_MODULE,
  829. .link = LIST_HEAD_INIT(em_meta_ops.link)
  830. };
  831. static int __init init_em_meta(void)
  832. {
  833. return tcf_em_register(&em_meta_ops);
  834. }
  835. static void __exit exit_em_meta(void)
  836. {
  837. tcf_em_unregister(&em_meta_ops);
  838. }
  839. MODULE_LICENSE("GPL");
  840. module_init(init_em_meta);
  841. module_exit(exit_em_meta);
  842. MODULE_ALIAS_TCF_EMATCH(TCF_EM_META);