geneve.c 50 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * GENEVE: Generic Network Virtualization Encapsulation
  4. *
  5. * Copyright (c) 2015 Red Hat, Inc.
  6. */
  7. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  8. #include <linux/kernel.h>
  9. #include <linux/module.h>
  10. #include <linux/etherdevice.h>
  11. #include <linux/hash.h>
  12. #include <net/ipv6_stubs.h>
  13. #include <net/dst_metadata.h>
  14. #include <net/gro_cells.h>
  15. #include <net/rtnetlink.h>
  16. #include <net/geneve.h>
  17. #include <net/protocol.h>
  18. #define GENEVE_NETDEV_VER "0.6"
  19. #define GENEVE_N_VID (1u << 24)
  20. #define GENEVE_VID_MASK (GENEVE_N_VID - 1)
  21. #define VNI_HASH_BITS 10
  22. #define VNI_HASH_SIZE (1<<VNI_HASH_BITS)
  23. static bool log_ecn_error = true;
  24. module_param(log_ecn_error, bool, 0644);
  25. MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
  26. #define GENEVE_VER 0
  27. #define GENEVE_BASE_HLEN (sizeof(struct udphdr) + sizeof(struct genevehdr))
  28. #define GENEVE_IPV4_HLEN (ETH_HLEN + sizeof(struct iphdr) + GENEVE_BASE_HLEN)
  29. #define GENEVE_IPV6_HLEN (ETH_HLEN + sizeof(struct ipv6hdr) + GENEVE_BASE_HLEN)
  30. /* per-network namespace private data for this module */
  31. struct geneve_net {
  32. struct list_head geneve_list;
  33. struct list_head sock_list;
  34. };
  35. static unsigned int geneve_net_id;
  36. struct geneve_dev_node {
  37. struct hlist_node hlist;
  38. struct geneve_dev *geneve;
  39. };
  40. struct geneve_config {
  41. struct ip_tunnel_info info;
  42. bool collect_md;
  43. bool use_udp6_rx_checksums;
  44. bool ttl_inherit;
  45. enum ifla_geneve_df df;
  46. };
  47. /* Pseudo network device */
  48. struct geneve_dev {
  49. struct geneve_dev_node hlist4; /* vni hash table for IPv4 socket */
  50. #if IS_ENABLED(CONFIG_IPV6)
  51. struct geneve_dev_node hlist6; /* vni hash table for IPv6 socket */
  52. #endif
  53. struct net *net; /* netns for packet i/o */
  54. struct net_device *dev; /* netdev for geneve tunnel */
  55. struct geneve_sock __rcu *sock4; /* IPv4 socket used for geneve tunnel */
  56. #if IS_ENABLED(CONFIG_IPV6)
  57. struct geneve_sock __rcu *sock6; /* IPv6 socket used for geneve tunnel */
  58. #endif
  59. struct list_head next; /* geneve's per namespace list */
  60. struct gro_cells gro_cells;
  61. struct geneve_config cfg;
  62. };
  63. struct geneve_sock {
  64. bool collect_md;
  65. struct list_head list;
  66. struct socket *sock;
  67. struct rcu_head rcu;
  68. int refcnt;
  69. struct hlist_head vni_list[VNI_HASH_SIZE];
  70. };
  71. static inline __u32 geneve_net_vni_hash(u8 vni[3])
  72. {
  73. __u32 vnid;
  74. vnid = (vni[0] << 16) | (vni[1] << 8) | vni[2];
  75. return hash_32(vnid, VNI_HASH_BITS);
  76. }
  77. static __be64 vni_to_tunnel_id(const __u8 *vni)
  78. {
  79. #ifdef __BIG_ENDIAN
  80. return (vni[0] << 16) | (vni[1] << 8) | vni[2];
  81. #else
  82. return (__force __be64)(((__force u64)vni[0] << 40) |
  83. ((__force u64)vni[1] << 48) |
  84. ((__force u64)vni[2] << 56));
  85. #endif
  86. }
  87. /* Convert 64 bit tunnel ID to 24 bit VNI. */
  88. static void tunnel_id_to_vni(__be64 tun_id, __u8 *vni)
  89. {
  90. #ifdef __BIG_ENDIAN
  91. vni[0] = (__force __u8)(tun_id >> 16);
  92. vni[1] = (__force __u8)(tun_id >> 8);
  93. vni[2] = (__force __u8)tun_id;
  94. #else
  95. vni[0] = (__force __u8)((__force u64)tun_id >> 40);
  96. vni[1] = (__force __u8)((__force u64)tun_id >> 48);
  97. vni[2] = (__force __u8)((__force u64)tun_id >> 56);
  98. #endif
  99. }
  100. static bool eq_tun_id_and_vni(u8 *tun_id, u8 *vni)
  101. {
  102. return !memcmp(vni, &tun_id[5], 3);
  103. }
  104. static sa_family_t geneve_get_sk_family(struct geneve_sock *gs)
  105. {
  106. return gs->sock->sk->sk_family;
  107. }
  108. static struct geneve_dev *geneve_lookup(struct geneve_sock *gs,
  109. __be32 addr, u8 vni[])
  110. {
  111. struct hlist_head *vni_list_head;
  112. struct geneve_dev_node *node;
  113. __u32 hash;
  114. /* Find the device for this VNI */
  115. hash = geneve_net_vni_hash(vni);
  116. vni_list_head = &gs->vni_list[hash];
  117. hlist_for_each_entry_rcu(node, vni_list_head, hlist) {
  118. if (eq_tun_id_and_vni((u8 *)&node->geneve->cfg.info.key.tun_id, vni) &&
  119. addr == node->geneve->cfg.info.key.u.ipv4.dst)
  120. return node->geneve;
  121. }
  122. return NULL;
  123. }
  124. #if IS_ENABLED(CONFIG_IPV6)
  125. static struct geneve_dev *geneve6_lookup(struct geneve_sock *gs,
  126. struct in6_addr addr6, u8 vni[])
  127. {
  128. struct hlist_head *vni_list_head;
  129. struct geneve_dev_node *node;
  130. __u32 hash;
  131. /* Find the device for this VNI */
  132. hash = geneve_net_vni_hash(vni);
  133. vni_list_head = &gs->vni_list[hash];
  134. hlist_for_each_entry_rcu(node, vni_list_head, hlist) {
  135. if (eq_tun_id_and_vni((u8 *)&node->geneve->cfg.info.key.tun_id, vni) &&
  136. ipv6_addr_equal(&addr6, &node->geneve->cfg.info.key.u.ipv6.dst))
  137. return node->geneve;
  138. }
  139. return NULL;
  140. }
  141. #endif
  142. static inline struct genevehdr *geneve_hdr(const struct sk_buff *skb)
  143. {
  144. return (struct genevehdr *)(udp_hdr(skb) + 1);
  145. }
  146. static struct geneve_dev *geneve_lookup_skb(struct geneve_sock *gs,
  147. struct sk_buff *skb)
  148. {
  149. static u8 zero_vni[3];
  150. u8 *vni;
  151. if (geneve_get_sk_family(gs) == AF_INET) {
  152. struct iphdr *iph;
  153. __be32 addr;
  154. iph = ip_hdr(skb); /* outer IP header... */
  155. if (gs->collect_md) {
  156. vni = zero_vni;
  157. addr = 0;
  158. } else {
  159. vni = geneve_hdr(skb)->vni;
  160. addr = iph->saddr;
  161. }
  162. return geneve_lookup(gs, addr, vni);
  163. #if IS_ENABLED(CONFIG_IPV6)
  164. } else if (geneve_get_sk_family(gs) == AF_INET6) {
  165. static struct in6_addr zero_addr6;
  166. struct ipv6hdr *ip6h;
  167. struct in6_addr addr6;
  168. ip6h = ipv6_hdr(skb); /* outer IPv6 header... */
  169. if (gs->collect_md) {
  170. vni = zero_vni;
  171. addr6 = zero_addr6;
  172. } else {
  173. vni = geneve_hdr(skb)->vni;
  174. addr6 = ip6h->saddr;
  175. }
  176. return geneve6_lookup(gs, addr6, vni);
  177. #endif
  178. }
  179. return NULL;
  180. }
  181. /* geneve receive/decap routine */
  182. static void geneve_rx(struct geneve_dev *geneve, struct geneve_sock *gs,
  183. struct sk_buff *skb)
  184. {
  185. struct genevehdr *gnvh = geneve_hdr(skb);
  186. struct metadata_dst *tun_dst = NULL;
  187. unsigned int len;
  188. int err = 0;
  189. void *oiph;
  190. if (ip_tunnel_collect_metadata() || gs->collect_md) {
  191. __be16 flags;
  192. flags = TUNNEL_KEY | (gnvh->oam ? TUNNEL_OAM : 0) |
  193. (gnvh->critical ? TUNNEL_CRIT_OPT : 0);
  194. tun_dst = udp_tun_rx_dst(skb, geneve_get_sk_family(gs), flags,
  195. vni_to_tunnel_id(gnvh->vni),
  196. gnvh->opt_len * 4);
  197. if (!tun_dst) {
  198. geneve->dev->stats.rx_dropped++;
  199. goto drop;
  200. }
  201. /* Update tunnel dst according to Geneve options. */
  202. ip_tunnel_info_opts_set(&tun_dst->u.tun_info,
  203. gnvh->options, gnvh->opt_len * 4,
  204. TUNNEL_GENEVE_OPT);
  205. } else {
  206. /* Drop packets w/ critical options,
  207. * since we don't support any...
  208. */
  209. if (gnvh->critical) {
  210. geneve->dev->stats.rx_frame_errors++;
  211. geneve->dev->stats.rx_errors++;
  212. goto drop;
  213. }
  214. }
  215. skb_reset_mac_header(skb);
  216. skb->protocol = eth_type_trans(skb, geneve->dev);
  217. skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
  218. if (tun_dst)
  219. skb_dst_set(skb, &tun_dst->dst);
  220. /* Ignore packet loops (and multicast echo) */
  221. if (ether_addr_equal(eth_hdr(skb)->h_source, geneve->dev->dev_addr)) {
  222. geneve->dev->stats.rx_errors++;
  223. goto drop;
  224. }
  225. oiph = skb_network_header(skb);
  226. skb_reset_network_header(skb);
  227. if (geneve_get_sk_family(gs) == AF_INET)
  228. err = IP_ECN_decapsulate(oiph, skb);
  229. #if IS_ENABLED(CONFIG_IPV6)
  230. else
  231. err = IP6_ECN_decapsulate(oiph, skb);
  232. #endif
  233. if (unlikely(err)) {
  234. if (log_ecn_error) {
  235. if (geneve_get_sk_family(gs) == AF_INET)
  236. net_info_ratelimited("non-ECT from %pI4 "
  237. "with TOS=%#x\n",
  238. &((struct iphdr *)oiph)->saddr,
  239. ((struct iphdr *)oiph)->tos);
  240. #if IS_ENABLED(CONFIG_IPV6)
  241. else
  242. net_info_ratelimited("non-ECT from %pI6\n",
  243. &((struct ipv6hdr *)oiph)->saddr);
  244. #endif
  245. }
  246. if (err > 1) {
  247. ++geneve->dev->stats.rx_frame_errors;
  248. ++geneve->dev->stats.rx_errors;
  249. goto drop;
  250. }
  251. }
  252. len = skb->len;
  253. err = gro_cells_receive(&geneve->gro_cells, skb);
  254. if (likely(err == NET_RX_SUCCESS))
  255. dev_sw_netstats_rx_add(geneve->dev, len);
  256. return;
  257. drop:
  258. /* Consume bad packet */
  259. kfree_skb(skb);
  260. }
  261. /* Setup stats when device is created */
  262. static int geneve_init(struct net_device *dev)
  263. {
  264. struct geneve_dev *geneve = netdev_priv(dev);
  265. int err;
  266. dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
  267. if (!dev->tstats)
  268. return -ENOMEM;
  269. err = gro_cells_init(&geneve->gro_cells, dev);
  270. if (err) {
  271. free_percpu(dev->tstats);
  272. return err;
  273. }
  274. err = dst_cache_init(&geneve->cfg.info.dst_cache, GFP_KERNEL);
  275. if (err) {
  276. free_percpu(dev->tstats);
  277. gro_cells_destroy(&geneve->gro_cells);
  278. return err;
  279. }
  280. return 0;
  281. }
  282. static void geneve_uninit(struct net_device *dev)
  283. {
  284. struct geneve_dev *geneve = netdev_priv(dev);
  285. dst_cache_destroy(&geneve->cfg.info.dst_cache);
  286. gro_cells_destroy(&geneve->gro_cells);
  287. free_percpu(dev->tstats);
  288. }
  289. /* Callback from net/ipv4/udp.c to receive packets */
  290. static int geneve_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
  291. {
  292. struct genevehdr *geneveh;
  293. struct geneve_dev *geneve;
  294. struct geneve_sock *gs;
  295. int opts_len;
  296. /* Need UDP and Geneve header to be present */
  297. if (unlikely(!pskb_may_pull(skb, GENEVE_BASE_HLEN)))
  298. goto drop;
  299. /* Return packets with reserved bits set */
  300. geneveh = geneve_hdr(skb);
  301. if (unlikely(geneveh->ver != GENEVE_VER))
  302. goto drop;
  303. if (unlikely(geneveh->proto_type != htons(ETH_P_TEB)))
  304. goto drop;
  305. gs = rcu_dereference_sk_user_data(sk);
  306. if (!gs)
  307. goto drop;
  308. geneve = geneve_lookup_skb(gs, skb);
  309. if (!geneve)
  310. goto drop;
  311. opts_len = geneveh->opt_len * 4;
  312. if (iptunnel_pull_header(skb, GENEVE_BASE_HLEN + opts_len,
  313. htons(ETH_P_TEB),
  314. !net_eq(geneve->net, dev_net(geneve->dev)))) {
  315. geneve->dev->stats.rx_dropped++;
  316. goto drop;
  317. }
  318. geneve_rx(geneve, gs, skb);
  319. return 0;
  320. drop:
  321. /* Consume bad packet */
  322. kfree_skb(skb);
  323. return 0;
  324. }
  325. /* Callback from net/ipv{4,6}/udp.c to check that we have a tunnel for errors */
  326. static int geneve_udp_encap_err_lookup(struct sock *sk, struct sk_buff *skb)
  327. {
  328. struct genevehdr *geneveh;
  329. struct geneve_sock *gs;
  330. u8 zero_vni[3] = { 0 };
  331. u8 *vni = zero_vni;
  332. if (!pskb_may_pull(skb, skb_transport_offset(skb) + GENEVE_BASE_HLEN))
  333. return -EINVAL;
  334. geneveh = geneve_hdr(skb);
  335. if (geneveh->ver != GENEVE_VER)
  336. return -EINVAL;
  337. if (geneveh->proto_type != htons(ETH_P_TEB))
  338. return -EINVAL;
  339. gs = rcu_dereference_sk_user_data(sk);
  340. if (!gs)
  341. return -ENOENT;
  342. if (geneve_get_sk_family(gs) == AF_INET) {
  343. struct iphdr *iph = ip_hdr(skb);
  344. __be32 addr4 = 0;
  345. if (!gs->collect_md) {
  346. vni = geneve_hdr(skb)->vni;
  347. addr4 = iph->daddr;
  348. }
  349. return geneve_lookup(gs, addr4, vni) ? 0 : -ENOENT;
  350. }
  351. #if IS_ENABLED(CONFIG_IPV6)
  352. if (geneve_get_sk_family(gs) == AF_INET6) {
  353. struct ipv6hdr *ip6h = ipv6_hdr(skb);
  354. struct in6_addr addr6;
  355. memset(&addr6, 0, sizeof(struct in6_addr));
  356. if (!gs->collect_md) {
  357. vni = geneve_hdr(skb)->vni;
  358. addr6 = ip6h->daddr;
  359. }
  360. return geneve6_lookup(gs, addr6, vni) ? 0 : -ENOENT;
  361. }
  362. #endif
  363. return -EPFNOSUPPORT;
  364. }
  365. static struct socket *geneve_create_sock(struct net *net, bool ipv6,
  366. __be16 port, bool ipv6_rx_csum)
  367. {
  368. struct socket *sock;
  369. struct udp_port_cfg udp_conf;
  370. int err;
  371. memset(&udp_conf, 0, sizeof(udp_conf));
  372. if (ipv6) {
  373. udp_conf.family = AF_INET6;
  374. udp_conf.ipv6_v6only = 1;
  375. udp_conf.use_udp6_rx_checksums = ipv6_rx_csum;
  376. } else {
  377. udp_conf.family = AF_INET;
  378. udp_conf.local_ip.s_addr = htonl(INADDR_ANY);
  379. }
  380. udp_conf.local_udp_port = port;
  381. /* Open UDP socket */
  382. err = udp_sock_create(net, &udp_conf, &sock);
  383. if (err < 0)
  384. return ERR_PTR(err);
  385. return sock;
  386. }
  387. static int geneve_hlen(struct genevehdr *gh)
  388. {
  389. return sizeof(*gh) + gh->opt_len * 4;
  390. }
  391. static struct sk_buff *geneve_gro_receive(struct sock *sk,
  392. struct list_head *head,
  393. struct sk_buff *skb)
  394. {
  395. struct sk_buff *pp = NULL;
  396. struct sk_buff *p;
  397. struct genevehdr *gh, *gh2;
  398. unsigned int hlen, gh_len, off_gnv;
  399. const struct packet_offload *ptype;
  400. __be16 type;
  401. int flush = 1;
  402. off_gnv = skb_gro_offset(skb);
  403. hlen = off_gnv + sizeof(*gh);
  404. gh = skb_gro_header_fast(skb, off_gnv);
  405. if (skb_gro_header_hard(skb, hlen)) {
  406. gh = skb_gro_header_slow(skb, hlen, off_gnv);
  407. if (unlikely(!gh))
  408. goto out;
  409. }
  410. if (gh->ver != GENEVE_VER || gh->oam)
  411. goto out;
  412. gh_len = geneve_hlen(gh);
  413. hlen = off_gnv + gh_len;
  414. if (skb_gro_header_hard(skb, hlen)) {
  415. gh = skb_gro_header_slow(skb, hlen, off_gnv);
  416. if (unlikely(!gh))
  417. goto out;
  418. }
  419. list_for_each_entry(p, head, list) {
  420. if (!NAPI_GRO_CB(p)->same_flow)
  421. continue;
  422. gh2 = (struct genevehdr *)(p->data + off_gnv);
  423. if (gh->opt_len != gh2->opt_len ||
  424. memcmp(gh, gh2, gh_len)) {
  425. NAPI_GRO_CB(p)->same_flow = 0;
  426. continue;
  427. }
  428. }
  429. type = gh->proto_type;
  430. rcu_read_lock();
  431. ptype = gro_find_receive_by_type(type);
  432. if (!ptype)
  433. goto out_unlock;
  434. skb_gro_pull(skb, gh_len);
  435. skb_gro_postpull_rcsum(skb, gh, gh_len);
  436. pp = call_gro_receive(ptype->callbacks.gro_receive, head, skb);
  437. flush = 0;
  438. out_unlock:
  439. rcu_read_unlock();
  440. out:
  441. skb_gro_flush_final(skb, pp, flush);
  442. return pp;
  443. }
  444. static int geneve_gro_complete(struct sock *sk, struct sk_buff *skb,
  445. int nhoff)
  446. {
  447. struct genevehdr *gh;
  448. struct packet_offload *ptype;
  449. __be16 type;
  450. int gh_len;
  451. int err = -ENOSYS;
  452. gh = (struct genevehdr *)(skb->data + nhoff);
  453. gh_len = geneve_hlen(gh);
  454. type = gh->proto_type;
  455. rcu_read_lock();
  456. ptype = gro_find_complete_by_type(type);
  457. if (ptype)
  458. err = ptype->callbacks.gro_complete(skb, nhoff + gh_len);
  459. rcu_read_unlock();
  460. skb_set_inner_mac_header(skb, nhoff + gh_len);
  461. return err;
  462. }
  463. /* Create new listen socket if needed */
  464. static struct geneve_sock *geneve_socket_create(struct net *net, __be16 port,
  465. bool ipv6, bool ipv6_rx_csum)
  466. {
  467. struct geneve_net *gn = net_generic(net, geneve_net_id);
  468. struct geneve_sock *gs;
  469. struct socket *sock;
  470. struct udp_tunnel_sock_cfg tunnel_cfg;
  471. int h;
  472. gs = kzalloc(sizeof(*gs), GFP_KERNEL);
  473. if (!gs)
  474. return ERR_PTR(-ENOMEM);
  475. sock = geneve_create_sock(net, ipv6, port, ipv6_rx_csum);
  476. if (IS_ERR(sock)) {
  477. kfree(gs);
  478. return ERR_CAST(sock);
  479. }
  480. gs->sock = sock;
  481. gs->refcnt = 1;
  482. for (h = 0; h < VNI_HASH_SIZE; ++h)
  483. INIT_HLIST_HEAD(&gs->vni_list[h]);
  484. /* Initialize the geneve udp offloads structure */
  485. udp_tunnel_notify_add_rx_port(gs->sock, UDP_TUNNEL_TYPE_GENEVE);
  486. /* Mark socket as an encapsulation socket */
  487. memset(&tunnel_cfg, 0, sizeof(tunnel_cfg));
  488. tunnel_cfg.sk_user_data = gs;
  489. tunnel_cfg.encap_type = 1;
  490. tunnel_cfg.gro_receive = geneve_gro_receive;
  491. tunnel_cfg.gro_complete = geneve_gro_complete;
  492. tunnel_cfg.encap_rcv = geneve_udp_encap_recv;
  493. tunnel_cfg.encap_err_lookup = geneve_udp_encap_err_lookup;
  494. tunnel_cfg.encap_destroy = NULL;
  495. setup_udp_tunnel_sock(net, sock, &tunnel_cfg);
  496. list_add(&gs->list, &gn->sock_list);
  497. return gs;
  498. }
  499. static void __geneve_sock_release(struct geneve_sock *gs)
  500. {
  501. if (!gs || --gs->refcnt)
  502. return;
  503. list_del(&gs->list);
  504. udp_tunnel_notify_del_rx_port(gs->sock, UDP_TUNNEL_TYPE_GENEVE);
  505. udp_tunnel_sock_release(gs->sock);
  506. kfree_rcu(gs, rcu);
  507. }
  508. static void geneve_sock_release(struct geneve_dev *geneve)
  509. {
  510. struct geneve_sock *gs4 = rtnl_dereference(geneve->sock4);
  511. #if IS_ENABLED(CONFIG_IPV6)
  512. struct geneve_sock *gs6 = rtnl_dereference(geneve->sock6);
  513. rcu_assign_pointer(geneve->sock6, NULL);
  514. #endif
  515. rcu_assign_pointer(geneve->sock4, NULL);
  516. synchronize_net();
  517. __geneve_sock_release(gs4);
  518. #if IS_ENABLED(CONFIG_IPV6)
  519. __geneve_sock_release(gs6);
  520. #endif
  521. }
  522. static struct geneve_sock *geneve_find_sock(struct geneve_net *gn,
  523. sa_family_t family,
  524. __be16 dst_port)
  525. {
  526. struct geneve_sock *gs;
  527. list_for_each_entry(gs, &gn->sock_list, list) {
  528. if (inet_sk(gs->sock->sk)->inet_sport == dst_port &&
  529. geneve_get_sk_family(gs) == family) {
  530. return gs;
  531. }
  532. }
  533. return NULL;
  534. }
  535. static int geneve_sock_add(struct geneve_dev *geneve, bool ipv6)
  536. {
  537. struct net *net = geneve->net;
  538. struct geneve_net *gn = net_generic(net, geneve_net_id);
  539. struct geneve_dev_node *node;
  540. struct geneve_sock *gs;
  541. __u8 vni[3];
  542. __u32 hash;
  543. gs = geneve_find_sock(gn, ipv6 ? AF_INET6 : AF_INET, geneve->cfg.info.key.tp_dst);
  544. if (gs) {
  545. gs->refcnt++;
  546. goto out;
  547. }
  548. gs = geneve_socket_create(net, geneve->cfg.info.key.tp_dst, ipv6,
  549. geneve->cfg.use_udp6_rx_checksums);
  550. if (IS_ERR(gs))
  551. return PTR_ERR(gs);
  552. out:
  553. gs->collect_md = geneve->cfg.collect_md;
  554. #if IS_ENABLED(CONFIG_IPV6)
  555. if (ipv6) {
  556. rcu_assign_pointer(geneve->sock6, gs);
  557. node = &geneve->hlist6;
  558. } else
  559. #endif
  560. {
  561. rcu_assign_pointer(geneve->sock4, gs);
  562. node = &geneve->hlist4;
  563. }
  564. node->geneve = geneve;
  565. tunnel_id_to_vni(geneve->cfg.info.key.tun_id, vni);
  566. hash = geneve_net_vni_hash(vni);
  567. hlist_add_head_rcu(&node->hlist, &gs->vni_list[hash]);
  568. return 0;
  569. }
  570. static int geneve_open(struct net_device *dev)
  571. {
  572. struct geneve_dev *geneve = netdev_priv(dev);
  573. bool metadata = geneve->cfg.collect_md;
  574. bool ipv4, ipv6;
  575. int ret = 0;
  576. ipv6 = geneve->cfg.info.mode & IP_TUNNEL_INFO_IPV6 || metadata;
  577. ipv4 = !ipv6 || metadata;
  578. #if IS_ENABLED(CONFIG_IPV6)
  579. if (ipv6) {
  580. ret = geneve_sock_add(geneve, true);
  581. if (ret < 0 && ret != -EAFNOSUPPORT)
  582. ipv4 = false;
  583. }
  584. #endif
  585. if (ipv4)
  586. ret = geneve_sock_add(geneve, false);
  587. if (ret < 0)
  588. geneve_sock_release(geneve);
  589. return ret;
  590. }
  591. static int geneve_stop(struct net_device *dev)
  592. {
  593. struct geneve_dev *geneve = netdev_priv(dev);
  594. hlist_del_init_rcu(&geneve->hlist4.hlist);
  595. #if IS_ENABLED(CONFIG_IPV6)
  596. hlist_del_init_rcu(&geneve->hlist6.hlist);
  597. #endif
  598. geneve_sock_release(geneve);
  599. return 0;
  600. }
  601. static void geneve_build_header(struct genevehdr *geneveh,
  602. const struct ip_tunnel_info *info)
  603. {
  604. geneveh->ver = GENEVE_VER;
  605. geneveh->opt_len = info->options_len / 4;
  606. geneveh->oam = !!(info->key.tun_flags & TUNNEL_OAM);
  607. geneveh->critical = !!(info->key.tun_flags & TUNNEL_CRIT_OPT);
  608. geneveh->rsvd1 = 0;
  609. tunnel_id_to_vni(info->key.tun_id, geneveh->vni);
  610. geneveh->proto_type = htons(ETH_P_TEB);
  611. geneveh->rsvd2 = 0;
  612. if (info->key.tun_flags & TUNNEL_GENEVE_OPT)
  613. ip_tunnel_info_opts_get(geneveh->options, info);
  614. }
  615. static int geneve_build_skb(struct dst_entry *dst, struct sk_buff *skb,
  616. const struct ip_tunnel_info *info,
  617. bool xnet, int ip_hdr_len)
  618. {
  619. bool udp_sum = !!(info->key.tun_flags & TUNNEL_CSUM);
  620. struct genevehdr *gnvh;
  621. int min_headroom;
  622. int err;
  623. skb_reset_mac_header(skb);
  624. skb_scrub_packet(skb, xnet);
  625. min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len +
  626. GENEVE_BASE_HLEN + info->options_len + ip_hdr_len;
  627. err = skb_cow_head(skb, min_headroom);
  628. if (unlikely(err))
  629. goto free_dst;
  630. err = udp_tunnel_handle_offloads(skb, udp_sum);
  631. if (err)
  632. goto free_dst;
  633. gnvh = __skb_push(skb, sizeof(*gnvh) + info->options_len);
  634. geneve_build_header(gnvh, info);
  635. skb_set_inner_protocol(skb, htons(ETH_P_TEB));
  636. return 0;
  637. free_dst:
  638. dst_release(dst);
  639. return err;
  640. }
  641. static struct rtable *geneve_get_v4_rt(struct sk_buff *skb,
  642. struct net_device *dev,
  643. struct geneve_sock *gs4,
  644. struct flowi4 *fl4,
  645. const struct ip_tunnel_info *info,
  646. __be16 dport, __be16 sport)
  647. {
  648. bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
  649. struct geneve_dev *geneve = netdev_priv(dev);
  650. struct dst_cache *dst_cache;
  651. struct rtable *rt = NULL;
  652. __u8 tos;
  653. if (!gs4)
  654. return ERR_PTR(-EIO);
  655. memset(fl4, 0, sizeof(*fl4));
  656. fl4->flowi4_mark = skb->mark;
  657. fl4->flowi4_proto = IPPROTO_UDP;
  658. fl4->daddr = info->key.u.ipv4.dst;
  659. fl4->saddr = info->key.u.ipv4.src;
  660. fl4->fl4_dport = dport;
  661. fl4->fl4_sport = sport;
  662. tos = info->key.tos;
  663. if ((tos == 1) && !geneve->cfg.collect_md) {
  664. tos = ip_tunnel_get_dsfield(ip_hdr(skb), skb);
  665. use_cache = false;
  666. }
  667. fl4->flowi4_tos = RT_TOS(tos);
  668. dst_cache = (struct dst_cache *)&info->dst_cache;
  669. if (use_cache) {
  670. rt = dst_cache_get_ip4(dst_cache, &fl4->saddr);
  671. if (rt)
  672. return rt;
  673. }
  674. rt = ip_route_output_key(geneve->net, fl4);
  675. if (IS_ERR(rt)) {
  676. netdev_dbg(dev, "no route to %pI4\n", &fl4->daddr);
  677. return ERR_PTR(-ENETUNREACH);
  678. }
  679. if (rt->dst.dev == dev) { /* is this necessary? */
  680. netdev_dbg(dev, "circular route to %pI4\n", &fl4->daddr);
  681. ip_rt_put(rt);
  682. return ERR_PTR(-ELOOP);
  683. }
  684. if (use_cache)
  685. dst_cache_set_ip4(dst_cache, &rt->dst, fl4->saddr);
  686. return rt;
  687. }
  688. #if IS_ENABLED(CONFIG_IPV6)
  689. static struct dst_entry *geneve_get_v6_dst(struct sk_buff *skb,
  690. struct net_device *dev,
  691. struct geneve_sock *gs6,
  692. struct flowi6 *fl6,
  693. const struct ip_tunnel_info *info,
  694. __be16 dport, __be16 sport)
  695. {
  696. bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
  697. struct geneve_dev *geneve = netdev_priv(dev);
  698. struct dst_entry *dst = NULL;
  699. struct dst_cache *dst_cache;
  700. __u8 prio;
  701. if (!gs6)
  702. return ERR_PTR(-EIO);
  703. memset(fl6, 0, sizeof(*fl6));
  704. fl6->flowi6_mark = skb->mark;
  705. fl6->flowi6_proto = IPPROTO_UDP;
  706. fl6->daddr = info->key.u.ipv6.dst;
  707. fl6->saddr = info->key.u.ipv6.src;
  708. fl6->fl6_dport = dport;
  709. fl6->fl6_sport = sport;
  710. prio = info->key.tos;
  711. if ((prio == 1) && !geneve->cfg.collect_md) {
  712. prio = ip_tunnel_get_dsfield(ip_hdr(skb), skb);
  713. use_cache = false;
  714. }
  715. fl6->flowlabel = ip6_make_flowinfo(RT_TOS(prio),
  716. info->key.label);
  717. dst_cache = (struct dst_cache *)&info->dst_cache;
  718. if (use_cache) {
  719. dst = dst_cache_get_ip6(dst_cache, &fl6->saddr);
  720. if (dst)
  721. return dst;
  722. }
  723. dst = ipv6_stub->ipv6_dst_lookup_flow(geneve->net, gs6->sock->sk, fl6,
  724. NULL);
  725. if (IS_ERR(dst)) {
  726. netdev_dbg(dev, "no route to %pI6\n", &fl6->daddr);
  727. return ERR_PTR(-ENETUNREACH);
  728. }
  729. if (dst->dev == dev) { /* is this necessary? */
  730. netdev_dbg(dev, "circular route to %pI6\n", &fl6->daddr);
  731. dst_release(dst);
  732. return ERR_PTR(-ELOOP);
  733. }
  734. if (use_cache)
  735. dst_cache_set_ip6(dst_cache, dst, &fl6->saddr);
  736. return dst;
  737. }
  738. #endif
  739. static int geneve_xmit_skb(struct sk_buff *skb, struct net_device *dev,
  740. struct geneve_dev *geneve,
  741. const struct ip_tunnel_info *info)
  742. {
  743. bool xnet = !net_eq(geneve->net, dev_net(geneve->dev));
  744. struct geneve_sock *gs4 = rcu_dereference(geneve->sock4);
  745. const struct ip_tunnel_key *key = &info->key;
  746. struct rtable *rt;
  747. struct flowi4 fl4;
  748. __u8 tos, ttl;
  749. __be16 df = 0;
  750. __be16 sport;
  751. int err;
  752. if (!pskb_inet_may_pull(skb))
  753. return -EINVAL;
  754. sport = udp_flow_src_port(geneve->net, skb, 1, USHRT_MAX, true);
  755. rt = geneve_get_v4_rt(skb, dev, gs4, &fl4, info,
  756. geneve->cfg.info.key.tp_dst, sport);
  757. if (IS_ERR(rt))
  758. return PTR_ERR(rt);
  759. err = skb_tunnel_check_pmtu(skb, &rt->dst,
  760. GENEVE_IPV4_HLEN + info->options_len,
  761. netif_is_any_bridge_port(dev));
  762. if (err < 0) {
  763. dst_release(&rt->dst);
  764. return err;
  765. } else if (err) {
  766. struct ip_tunnel_info *info;
  767. info = skb_tunnel_info(skb);
  768. if (info) {
  769. struct ip_tunnel_info *unclone;
  770. unclone = skb_tunnel_info_unclone(skb);
  771. if (unlikely(!unclone)) {
  772. dst_release(&rt->dst);
  773. return -ENOMEM;
  774. }
  775. unclone->key.u.ipv4.dst = fl4.saddr;
  776. unclone->key.u.ipv4.src = fl4.daddr;
  777. }
  778. if (!pskb_may_pull(skb, ETH_HLEN)) {
  779. dst_release(&rt->dst);
  780. return -EINVAL;
  781. }
  782. skb->protocol = eth_type_trans(skb, geneve->dev);
  783. netif_rx(skb);
  784. dst_release(&rt->dst);
  785. return -EMSGSIZE;
  786. }
  787. if (geneve->cfg.collect_md) {
  788. tos = ip_tunnel_ecn_encap(key->tos, ip_hdr(skb), skb);
  789. ttl = key->ttl;
  790. df = key->tun_flags & TUNNEL_DONT_FRAGMENT ? htons(IP_DF) : 0;
  791. } else {
  792. tos = ip_tunnel_ecn_encap(fl4.flowi4_tos, ip_hdr(skb), skb);
  793. if (geneve->cfg.ttl_inherit)
  794. ttl = ip_tunnel_get_ttl(ip_hdr(skb), skb);
  795. else
  796. ttl = key->ttl;
  797. ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);
  798. if (geneve->cfg.df == GENEVE_DF_SET) {
  799. df = htons(IP_DF);
  800. } else if (geneve->cfg.df == GENEVE_DF_INHERIT) {
  801. struct ethhdr *eth = eth_hdr(skb);
  802. if (ntohs(eth->h_proto) == ETH_P_IPV6) {
  803. df = htons(IP_DF);
  804. } else if (ntohs(eth->h_proto) == ETH_P_IP) {
  805. struct iphdr *iph = ip_hdr(skb);
  806. if (iph->frag_off & htons(IP_DF))
  807. df = htons(IP_DF);
  808. }
  809. }
  810. }
  811. err = geneve_build_skb(&rt->dst, skb, info, xnet, sizeof(struct iphdr));
  812. if (unlikely(err))
  813. return err;
  814. udp_tunnel_xmit_skb(rt, gs4->sock->sk, skb, fl4.saddr, fl4.daddr,
  815. tos, ttl, df, sport, geneve->cfg.info.key.tp_dst,
  816. !net_eq(geneve->net, dev_net(geneve->dev)),
  817. !(info->key.tun_flags & TUNNEL_CSUM));
  818. return 0;
  819. }
  820. #if IS_ENABLED(CONFIG_IPV6)
  821. static int geneve6_xmit_skb(struct sk_buff *skb, struct net_device *dev,
  822. struct geneve_dev *geneve,
  823. const struct ip_tunnel_info *info)
  824. {
  825. bool xnet = !net_eq(geneve->net, dev_net(geneve->dev));
  826. struct geneve_sock *gs6 = rcu_dereference(geneve->sock6);
  827. const struct ip_tunnel_key *key = &info->key;
  828. struct dst_entry *dst = NULL;
  829. struct flowi6 fl6;
  830. __u8 prio, ttl;
  831. __be16 sport;
  832. int err;
  833. if (!pskb_inet_may_pull(skb))
  834. return -EINVAL;
  835. sport = udp_flow_src_port(geneve->net, skb, 1, USHRT_MAX, true);
  836. dst = geneve_get_v6_dst(skb, dev, gs6, &fl6, info,
  837. geneve->cfg.info.key.tp_dst, sport);
  838. if (IS_ERR(dst))
  839. return PTR_ERR(dst);
  840. err = skb_tunnel_check_pmtu(skb, dst,
  841. GENEVE_IPV6_HLEN + info->options_len,
  842. netif_is_any_bridge_port(dev));
  843. if (err < 0) {
  844. dst_release(dst);
  845. return err;
  846. } else if (err) {
  847. struct ip_tunnel_info *info = skb_tunnel_info(skb);
  848. if (info) {
  849. struct ip_tunnel_info *unclone;
  850. unclone = skb_tunnel_info_unclone(skb);
  851. if (unlikely(!unclone)) {
  852. dst_release(dst);
  853. return -ENOMEM;
  854. }
  855. unclone->key.u.ipv6.dst = fl6.saddr;
  856. unclone->key.u.ipv6.src = fl6.daddr;
  857. }
  858. if (!pskb_may_pull(skb, ETH_HLEN)) {
  859. dst_release(dst);
  860. return -EINVAL;
  861. }
  862. skb->protocol = eth_type_trans(skb, geneve->dev);
  863. netif_rx(skb);
  864. dst_release(dst);
  865. return -EMSGSIZE;
  866. }
  867. if (geneve->cfg.collect_md) {
  868. prio = ip_tunnel_ecn_encap(key->tos, ip_hdr(skb), skb);
  869. ttl = key->ttl;
  870. } else {
  871. prio = ip_tunnel_ecn_encap(ip6_tclass(fl6.flowlabel),
  872. ip_hdr(skb), skb);
  873. if (geneve->cfg.ttl_inherit)
  874. ttl = ip_tunnel_get_ttl(ip_hdr(skb), skb);
  875. else
  876. ttl = key->ttl;
  877. ttl = ttl ? : ip6_dst_hoplimit(dst);
  878. }
  879. err = geneve_build_skb(dst, skb, info, xnet, sizeof(struct ipv6hdr));
  880. if (unlikely(err))
  881. return err;
  882. udp_tunnel6_xmit_skb(dst, gs6->sock->sk, skb, dev,
  883. &fl6.saddr, &fl6.daddr, prio, ttl,
  884. info->key.label, sport, geneve->cfg.info.key.tp_dst,
  885. !(info->key.tun_flags & TUNNEL_CSUM));
  886. return 0;
  887. }
  888. #endif
  889. static netdev_tx_t geneve_xmit(struct sk_buff *skb, struct net_device *dev)
  890. {
  891. struct geneve_dev *geneve = netdev_priv(dev);
  892. struct ip_tunnel_info *info = NULL;
  893. int err;
  894. if (geneve->cfg.collect_md) {
  895. info = skb_tunnel_info(skb);
  896. if (unlikely(!info || !(info->mode & IP_TUNNEL_INFO_TX))) {
  897. netdev_dbg(dev, "no tunnel metadata\n");
  898. dev_kfree_skb(skb);
  899. dev->stats.tx_dropped++;
  900. return NETDEV_TX_OK;
  901. }
  902. } else {
  903. info = &geneve->cfg.info;
  904. }
  905. rcu_read_lock();
  906. #if IS_ENABLED(CONFIG_IPV6)
  907. if (info->mode & IP_TUNNEL_INFO_IPV6)
  908. err = geneve6_xmit_skb(skb, dev, geneve, info);
  909. else
  910. #endif
  911. err = geneve_xmit_skb(skb, dev, geneve, info);
  912. rcu_read_unlock();
  913. if (likely(!err))
  914. return NETDEV_TX_OK;
  915. if (err != -EMSGSIZE)
  916. dev_kfree_skb(skb);
  917. if (err == -ELOOP)
  918. dev->stats.collisions++;
  919. else if (err == -ENETUNREACH)
  920. dev->stats.tx_carrier_errors++;
  921. dev->stats.tx_errors++;
  922. return NETDEV_TX_OK;
  923. }
  924. static int geneve_change_mtu(struct net_device *dev, int new_mtu)
  925. {
  926. if (new_mtu > dev->max_mtu)
  927. new_mtu = dev->max_mtu;
  928. else if (new_mtu < dev->min_mtu)
  929. new_mtu = dev->min_mtu;
  930. dev->mtu = new_mtu;
  931. return 0;
  932. }
  933. static int geneve_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
  934. {
  935. struct ip_tunnel_info *info = skb_tunnel_info(skb);
  936. struct geneve_dev *geneve = netdev_priv(dev);
  937. __be16 sport;
  938. if (ip_tunnel_info_af(info) == AF_INET) {
  939. struct rtable *rt;
  940. struct flowi4 fl4;
  941. struct geneve_sock *gs4 = rcu_dereference(geneve->sock4);
  942. sport = udp_flow_src_port(geneve->net, skb,
  943. 1, USHRT_MAX, true);
  944. rt = geneve_get_v4_rt(skb, dev, gs4, &fl4, info,
  945. geneve->cfg.info.key.tp_dst, sport);
  946. if (IS_ERR(rt))
  947. return PTR_ERR(rt);
  948. ip_rt_put(rt);
  949. info->key.u.ipv4.src = fl4.saddr;
  950. #if IS_ENABLED(CONFIG_IPV6)
  951. } else if (ip_tunnel_info_af(info) == AF_INET6) {
  952. struct dst_entry *dst;
  953. struct flowi6 fl6;
  954. struct geneve_sock *gs6 = rcu_dereference(geneve->sock6);
  955. sport = udp_flow_src_port(geneve->net, skb,
  956. 1, USHRT_MAX, true);
  957. dst = geneve_get_v6_dst(skb, dev, gs6, &fl6, info,
  958. geneve->cfg.info.key.tp_dst, sport);
  959. if (IS_ERR(dst))
  960. return PTR_ERR(dst);
  961. dst_release(dst);
  962. info->key.u.ipv6.src = fl6.saddr;
  963. #endif
  964. } else {
  965. return -EINVAL;
  966. }
  967. info->key.tp_src = sport;
  968. info->key.tp_dst = geneve->cfg.info.key.tp_dst;
  969. return 0;
  970. }
  971. static const struct net_device_ops geneve_netdev_ops = {
  972. .ndo_init = geneve_init,
  973. .ndo_uninit = geneve_uninit,
  974. .ndo_open = geneve_open,
  975. .ndo_stop = geneve_stop,
  976. .ndo_start_xmit = geneve_xmit,
  977. .ndo_get_stats64 = ip_tunnel_get_stats64,
  978. .ndo_change_mtu = geneve_change_mtu,
  979. .ndo_validate_addr = eth_validate_addr,
  980. .ndo_set_mac_address = eth_mac_addr,
  981. .ndo_fill_metadata_dst = geneve_fill_metadata_dst,
  982. };
  983. static void geneve_get_drvinfo(struct net_device *dev,
  984. struct ethtool_drvinfo *drvinfo)
  985. {
  986. strlcpy(drvinfo->version, GENEVE_NETDEV_VER, sizeof(drvinfo->version));
  987. strlcpy(drvinfo->driver, "geneve", sizeof(drvinfo->driver));
  988. }
  989. static const struct ethtool_ops geneve_ethtool_ops = {
  990. .get_drvinfo = geneve_get_drvinfo,
  991. .get_link = ethtool_op_get_link,
  992. };
  993. /* Info for udev, that this is a virtual tunnel endpoint */
  994. static struct device_type geneve_type = {
  995. .name = "geneve",
  996. };
  997. /* Calls the ndo_udp_tunnel_add of the caller in order to
  998. * supply the listening GENEVE udp ports. Callers are expected
  999. * to implement the ndo_udp_tunnel_add.
  1000. */
  1001. static void geneve_offload_rx_ports(struct net_device *dev, bool push)
  1002. {
  1003. struct net *net = dev_net(dev);
  1004. struct geneve_net *gn = net_generic(net, geneve_net_id);
  1005. struct geneve_sock *gs;
  1006. rcu_read_lock();
  1007. list_for_each_entry_rcu(gs, &gn->sock_list, list) {
  1008. if (push) {
  1009. udp_tunnel_push_rx_port(dev, gs->sock,
  1010. UDP_TUNNEL_TYPE_GENEVE);
  1011. } else {
  1012. udp_tunnel_drop_rx_port(dev, gs->sock,
  1013. UDP_TUNNEL_TYPE_GENEVE);
  1014. }
  1015. }
  1016. rcu_read_unlock();
  1017. }
  1018. /* Initialize the device structure. */
  1019. static void geneve_setup(struct net_device *dev)
  1020. {
  1021. ether_setup(dev);
  1022. dev->netdev_ops = &geneve_netdev_ops;
  1023. dev->ethtool_ops = &geneve_ethtool_ops;
  1024. dev->needs_free_netdev = true;
  1025. SET_NETDEV_DEVTYPE(dev, &geneve_type);
  1026. dev->features |= NETIF_F_LLTX;
  1027. dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
  1028. dev->features |= NETIF_F_RXCSUM;
  1029. dev->features |= NETIF_F_GSO_SOFTWARE;
  1030. dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
  1031. dev->hw_features |= NETIF_F_GSO_SOFTWARE;
  1032. /* MTU range: 68 - (something less than 65535) */
  1033. dev->min_mtu = ETH_MIN_MTU;
  1034. /* The max_mtu calculation does not take account of GENEVE
  1035. * options, to avoid excluding potentially valid
  1036. * configurations. This will be further reduced by IPvX hdr size.
  1037. */
  1038. dev->max_mtu = IP_MAX_MTU - GENEVE_BASE_HLEN - dev->hard_header_len;
  1039. netif_keep_dst(dev);
  1040. dev->priv_flags &= ~IFF_TX_SKB_SHARING;
  1041. dev->priv_flags |= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE;
  1042. eth_hw_addr_random(dev);
  1043. }
  1044. static const struct nla_policy geneve_policy[IFLA_GENEVE_MAX + 1] = {
  1045. [IFLA_GENEVE_ID] = { .type = NLA_U32 },
  1046. [IFLA_GENEVE_REMOTE] = { .len = sizeof_field(struct iphdr, daddr) },
  1047. [IFLA_GENEVE_REMOTE6] = { .len = sizeof(struct in6_addr) },
  1048. [IFLA_GENEVE_TTL] = { .type = NLA_U8 },
  1049. [IFLA_GENEVE_TOS] = { .type = NLA_U8 },
  1050. [IFLA_GENEVE_LABEL] = { .type = NLA_U32 },
  1051. [IFLA_GENEVE_PORT] = { .type = NLA_U16 },
  1052. [IFLA_GENEVE_COLLECT_METADATA] = { .type = NLA_FLAG },
  1053. [IFLA_GENEVE_UDP_CSUM] = { .type = NLA_U8 },
  1054. [IFLA_GENEVE_UDP_ZERO_CSUM6_TX] = { .type = NLA_U8 },
  1055. [IFLA_GENEVE_UDP_ZERO_CSUM6_RX] = { .type = NLA_U8 },
  1056. [IFLA_GENEVE_TTL_INHERIT] = { .type = NLA_U8 },
  1057. [IFLA_GENEVE_DF] = { .type = NLA_U8 },
  1058. };
  1059. static int geneve_validate(struct nlattr *tb[], struct nlattr *data[],
  1060. struct netlink_ext_ack *extack)
  1061. {
  1062. if (tb[IFLA_ADDRESS]) {
  1063. if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) {
  1064. NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_ADDRESS],
  1065. "Provided link layer address is not Ethernet");
  1066. return -EINVAL;
  1067. }
  1068. if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) {
  1069. NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_ADDRESS],
  1070. "Provided Ethernet address is not unicast");
  1071. return -EADDRNOTAVAIL;
  1072. }
  1073. }
  1074. if (!data) {
  1075. NL_SET_ERR_MSG(extack,
  1076. "Not enough attributes provided to perform the operation");
  1077. return -EINVAL;
  1078. }
  1079. if (data[IFLA_GENEVE_ID]) {
  1080. __u32 vni = nla_get_u32(data[IFLA_GENEVE_ID]);
  1081. if (vni >= GENEVE_N_VID) {
  1082. NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_ID],
  1083. "Geneve ID must be lower than 16777216");
  1084. return -ERANGE;
  1085. }
  1086. }
  1087. if (data[IFLA_GENEVE_DF]) {
  1088. enum ifla_geneve_df df = nla_get_u8(data[IFLA_GENEVE_DF]);
  1089. if (df < 0 || df > GENEVE_DF_MAX) {
  1090. NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_DF],
  1091. "Invalid DF attribute");
  1092. return -EINVAL;
  1093. }
  1094. }
  1095. return 0;
  1096. }
  1097. static struct geneve_dev *geneve_find_dev(struct geneve_net *gn,
  1098. const struct ip_tunnel_info *info,
  1099. bool *tun_on_same_port,
  1100. bool *tun_collect_md)
  1101. {
  1102. struct geneve_dev *geneve, *t = NULL;
  1103. *tun_on_same_port = false;
  1104. *tun_collect_md = false;
  1105. list_for_each_entry(geneve, &gn->geneve_list, next) {
  1106. if (info->key.tp_dst == geneve->cfg.info.key.tp_dst) {
  1107. *tun_collect_md = geneve->cfg.collect_md;
  1108. *tun_on_same_port = true;
  1109. }
  1110. if (info->key.tun_id == geneve->cfg.info.key.tun_id &&
  1111. info->key.tp_dst == geneve->cfg.info.key.tp_dst &&
  1112. !memcmp(&info->key.u, &geneve->cfg.info.key.u, sizeof(info->key.u)))
  1113. t = geneve;
  1114. }
  1115. return t;
  1116. }
  1117. static bool is_tnl_info_zero(const struct ip_tunnel_info *info)
  1118. {
  1119. return !(info->key.tun_id || info->key.tun_flags || info->key.tos ||
  1120. info->key.ttl || info->key.label || info->key.tp_src ||
  1121. memchr_inv(&info->key.u, 0, sizeof(info->key.u)));
  1122. }
  1123. static bool geneve_dst_addr_equal(struct ip_tunnel_info *a,
  1124. struct ip_tunnel_info *b)
  1125. {
  1126. if (ip_tunnel_info_af(a) == AF_INET)
  1127. return a->key.u.ipv4.dst == b->key.u.ipv4.dst;
  1128. else
  1129. return ipv6_addr_equal(&a->key.u.ipv6.dst, &b->key.u.ipv6.dst);
  1130. }
  1131. static int geneve_configure(struct net *net, struct net_device *dev,
  1132. struct netlink_ext_ack *extack,
  1133. const struct geneve_config *cfg)
  1134. {
  1135. struct geneve_net *gn = net_generic(net, geneve_net_id);
  1136. struct geneve_dev *t, *geneve = netdev_priv(dev);
  1137. const struct ip_tunnel_info *info = &cfg->info;
  1138. bool tun_collect_md, tun_on_same_port;
  1139. int err, encap_len;
  1140. if (cfg->collect_md && !is_tnl_info_zero(info)) {
  1141. NL_SET_ERR_MSG(extack,
  1142. "Device is externally controlled, so attributes (VNI, Port, and so on) must not be specified");
  1143. return -EINVAL;
  1144. }
  1145. geneve->net = net;
  1146. geneve->dev = dev;
  1147. t = geneve_find_dev(gn, info, &tun_on_same_port, &tun_collect_md);
  1148. if (t)
  1149. return -EBUSY;
  1150. /* make enough headroom for basic scenario */
  1151. encap_len = GENEVE_BASE_HLEN + ETH_HLEN;
  1152. if (!cfg->collect_md && ip_tunnel_info_af(info) == AF_INET) {
  1153. encap_len += sizeof(struct iphdr);
  1154. dev->max_mtu -= sizeof(struct iphdr);
  1155. } else {
  1156. encap_len += sizeof(struct ipv6hdr);
  1157. dev->max_mtu -= sizeof(struct ipv6hdr);
  1158. }
  1159. dev->needed_headroom = encap_len + ETH_HLEN;
  1160. if (cfg->collect_md) {
  1161. if (tun_on_same_port) {
  1162. NL_SET_ERR_MSG(extack,
  1163. "There can be only one externally controlled device on a destination port");
  1164. return -EPERM;
  1165. }
  1166. } else {
  1167. if (tun_collect_md) {
  1168. NL_SET_ERR_MSG(extack,
  1169. "There already exists an externally controlled device on this destination port");
  1170. return -EPERM;
  1171. }
  1172. }
  1173. dst_cache_reset(&geneve->cfg.info.dst_cache);
  1174. memcpy(&geneve->cfg, cfg, sizeof(*cfg));
  1175. err = register_netdevice(dev);
  1176. if (err)
  1177. return err;
  1178. list_add(&geneve->next, &gn->geneve_list);
  1179. return 0;
  1180. }
  1181. static void init_tnl_info(struct ip_tunnel_info *info, __u16 dst_port)
  1182. {
  1183. memset(info, 0, sizeof(*info));
  1184. info->key.tp_dst = htons(dst_port);
  1185. }
  1186. static int geneve_nl2info(struct nlattr *tb[], struct nlattr *data[],
  1187. struct netlink_ext_ack *extack,
  1188. struct geneve_config *cfg, bool changelink)
  1189. {
  1190. struct ip_tunnel_info *info = &cfg->info;
  1191. int attrtype;
  1192. if (data[IFLA_GENEVE_REMOTE] && data[IFLA_GENEVE_REMOTE6]) {
  1193. NL_SET_ERR_MSG(extack,
  1194. "Cannot specify both IPv4 and IPv6 Remote addresses");
  1195. return -EINVAL;
  1196. }
  1197. if (data[IFLA_GENEVE_REMOTE]) {
  1198. if (changelink && (ip_tunnel_info_af(info) == AF_INET6)) {
  1199. attrtype = IFLA_GENEVE_REMOTE;
  1200. goto change_notsup;
  1201. }
  1202. info->key.u.ipv4.dst =
  1203. nla_get_in_addr(data[IFLA_GENEVE_REMOTE]);
  1204. if (ipv4_is_multicast(info->key.u.ipv4.dst)) {
  1205. NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_REMOTE],
  1206. "Remote IPv4 address cannot be Multicast");
  1207. return -EINVAL;
  1208. }
  1209. }
  1210. if (data[IFLA_GENEVE_REMOTE6]) {
  1211. #if IS_ENABLED(CONFIG_IPV6)
  1212. if (changelink && (ip_tunnel_info_af(info) == AF_INET)) {
  1213. attrtype = IFLA_GENEVE_REMOTE6;
  1214. goto change_notsup;
  1215. }
  1216. info->mode = IP_TUNNEL_INFO_IPV6;
  1217. info->key.u.ipv6.dst =
  1218. nla_get_in6_addr(data[IFLA_GENEVE_REMOTE6]);
  1219. if (ipv6_addr_type(&info->key.u.ipv6.dst) &
  1220. IPV6_ADDR_LINKLOCAL) {
  1221. NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_REMOTE6],
  1222. "Remote IPv6 address cannot be link-local");
  1223. return -EINVAL;
  1224. }
  1225. if (ipv6_addr_is_multicast(&info->key.u.ipv6.dst)) {
  1226. NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_REMOTE6],
  1227. "Remote IPv6 address cannot be Multicast");
  1228. return -EINVAL;
  1229. }
  1230. info->key.tun_flags |= TUNNEL_CSUM;
  1231. cfg->use_udp6_rx_checksums = true;
  1232. #else
  1233. NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_REMOTE6],
  1234. "IPv6 support not enabled in the kernel");
  1235. return -EPFNOSUPPORT;
  1236. #endif
  1237. }
  1238. if (data[IFLA_GENEVE_ID]) {
  1239. __u32 vni;
  1240. __u8 tvni[3];
  1241. __be64 tunid;
  1242. vni = nla_get_u32(data[IFLA_GENEVE_ID]);
  1243. tvni[0] = (vni & 0x00ff0000) >> 16;
  1244. tvni[1] = (vni & 0x0000ff00) >> 8;
  1245. tvni[2] = vni & 0x000000ff;
  1246. tunid = vni_to_tunnel_id(tvni);
  1247. if (changelink && (tunid != info->key.tun_id)) {
  1248. attrtype = IFLA_GENEVE_ID;
  1249. goto change_notsup;
  1250. }
  1251. info->key.tun_id = tunid;
  1252. }
  1253. if (data[IFLA_GENEVE_TTL_INHERIT]) {
  1254. if (nla_get_u8(data[IFLA_GENEVE_TTL_INHERIT]))
  1255. cfg->ttl_inherit = true;
  1256. else
  1257. cfg->ttl_inherit = false;
  1258. } else if (data[IFLA_GENEVE_TTL]) {
  1259. info->key.ttl = nla_get_u8(data[IFLA_GENEVE_TTL]);
  1260. cfg->ttl_inherit = false;
  1261. }
  1262. if (data[IFLA_GENEVE_TOS])
  1263. info->key.tos = nla_get_u8(data[IFLA_GENEVE_TOS]);
  1264. if (data[IFLA_GENEVE_DF])
  1265. cfg->df = nla_get_u8(data[IFLA_GENEVE_DF]);
  1266. if (data[IFLA_GENEVE_LABEL]) {
  1267. info->key.label = nla_get_be32(data[IFLA_GENEVE_LABEL]) &
  1268. IPV6_FLOWLABEL_MASK;
  1269. if (info->key.label && (!(info->mode & IP_TUNNEL_INFO_IPV6))) {
  1270. NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_LABEL],
  1271. "Label attribute only applies for IPv6 Geneve devices");
  1272. return -EINVAL;
  1273. }
  1274. }
  1275. if (data[IFLA_GENEVE_PORT]) {
  1276. if (changelink) {
  1277. attrtype = IFLA_GENEVE_PORT;
  1278. goto change_notsup;
  1279. }
  1280. info->key.tp_dst = nla_get_be16(data[IFLA_GENEVE_PORT]);
  1281. }
  1282. if (data[IFLA_GENEVE_COLLECT_METADATA]) {
  1283. if (changelink) {
  1284. attrtype = IFLA_GENEVE_COLLECT_METADATA;
  1285. goto change_notsup;
  1286. }
  1287. cfg->collect_md = true;
  1288. }
  1289. if (data[IFLA_GENEVE_UDP_CSUM]) {
  1290. if (changelink) {
  1291. attrtype = IFLA_GENEVE_UDP_CSUM;
  1292. goto change_notsup;
  1293. }
  1294. if (nla_get_u8(data[IFLA_GENEVE_UDP_CSUM]))
  1295. info->key.tun_flags |= TUNNEL_CSUM;
  1296. }
  1297. if (data[IFLA_GENEVE_UDP_ZERO_CSUM6_TX]) {
  1298. #if IS_ENABLED(CONFIG_IPV6)
  1299. if (changelink) {
  1300. attrtype = IFLA_GENEVE_UDP_ZERO_CSUM6_TX;
  1301. goto change_notsup;
  1302. }
  1303. if (nla_get_u8(data[IFLA_GENEVE_UDP_ZERO_CSUM6_TX]))
  1304. info->key.tun_flags &= ~TUNNEL_CSUM;
  1305. #else
  1306. NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_UDP_ZERO_CSUM6_TX],
  1307. "IPv6 support not enabled in the kernel");
  1308. return -EPFNOSUPPORT;
  1309. #endif
  1310. }
  1311. if (data[IFLA_GENEVE_UDP_ZERO_CSUM6_RX]) {
  1312. #if IS_ENABLED(CONFIG_IPV6)
  1313. if (changelink) {
  1314. attrtype = IFLA_GENEVE_UDP_ZERO_CSUM6_RX;
  1315. goto change_notsup;
  1316. }
  1317. if (nla_get_u8(data[IFLA_GENEVE_UDP_ZERO_CSUM6_RX]))
  1318. cfg->use_udp6_rx_checksums = false;
  1319. #else
  1320. NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_UDP_ZERO_CSUM6_RX],
  1321. "IPv6 support not enabled in the kernel");
  1322. return -EPFNOSUPPORT;
  1323. #endif
  1324. }
  1325. return 0;
  1326. change_notsup:
  1327. NL_SET_ERR_MSG_ATTR(extack, data[attrtype],
  1328. "Changing VNI, Port, endpoint IP address family, external, and UDP checksum attributes are not supported");
  1329. return -EOPNOTSUPP;
  1330. }
  1331. static void geneve_link_config(struct net_device *dev,
  1332. struct ip_tunnel_info *info, struct nlattr *tb[])
  1333. {
  1334. struct geneve_dev *geneve = netdev_priv(dev);
  1335. int ldev_mtu = 0;
  1336. if (tb[IFLA_MTU]) {
  1337. geneve_change_mtu(dev, nla_get_u32(tb[IFLA_MTU]));
  1338. return;
  1339. }
  1340. switch (ip_tunnel_info_af(info)) {
  1341. case AF_INET: {
  1342. struct flowi4 fl4 = { .daddr = info->key.u.ipv4.dst };
  1343. struct rtable *rt = ip_route_output_key(geneve->net, &fl4);
  1344. if (!IS_ERR(rt) && rt->dst.dev) {
  1345. ldev_mtu = rt->dst.dev->mtu - GENEVE_IPV4_HLEN;
  1346. ip_rt_put(rt);
  1347. }
  1348. break;
  1349. }
  1350. #if IS_ENABLED(CONFIG_IPV6)
  1351. case AF_INET6: {
  1352. struct rt6_info *rt;
  1353. if (!__in6_dev_get(dev))
  1354. break;
  1355. rt = rt6_lookup(geneve->net, &info->key.u.ipv6.dst, NULL, 0,
  1356. NULL, 0);
  1357. if (rt && rt->dst.dev)
  1358. ldev_mtu = rt->dst.dev->mtu - GENEVE_IPV6_HLEN;
  1359. ip6_rt_put(rt);
  1360. break;
  1361. }
  1362. #endif
  1363. }
  1364. if (ldev_mtu <= 0)
  1365. return;
  1366. geneve_change_mtu(dev, ldev_mtu - info->options_len);
  1367. }
  1368. static int geneve_newlink(struct net *net, struct net_device *dev,
  1369. struct nlattr *tb[], struct nlattr *data[],
  1370. struct netlink_ext_ack *extack)
  1371. {
  1372. struct geneve_config cfg = {
  1373. .df = GENEVE_DF_UNSET,
  1374. .use_udp6_rx_checksums = false,
  1375. .ttl_inherit = false,
  1376. .collect_md = false,
  1377. };
  1378. int err;
  1379. init_tnl_info(&cfg.info, GENEVE_UDP_PORT);
  1380. err = geneve_nl2info(tb, data, extack, &cfg, false);
  1381. if (err)
  1382. return err;
  1383. err = geneve_configure(net, dev, extack, &cfg);
  1384. if (err)
  1385. return err;
  1386. geneve_link_config(dev, &cfg.info, tb);
  1387. return 0;
  1388. }
  1389. /* Quiesces the geneve device data path for both TX and RX.
  1390. *
  1391. * On transmit geneve checks for non-NULL geneve_sock before it proceeds.
  1392. * So, if we set that socket to NULL under RCU and wait for synchronize_net()
  1393. * to complete for the existing set of in-flight packets to be transmitted,
  1394. * then we would have quiesced the transmit data path. All the future packets
  1395. * will get dropped until we unquiesce the data path.
  1396. *
  1397. * On receive geneve dereference the geneve_sock stashed in the socket. So,
  1398. * if we set that to NULL under RCU and wait for synchronize_net() to
  1399. * complete, then we would have quiesced the receive data path.
  1400. */
  1401. static void geneve_quiesce(struct geneve_dev *geneve, struct geneve_sock **gs4,
  1402. struct geneve_sock **gs6)
  1403. {
  1404. *gs4 = rtnl_dereference(geneve->sock4);
  1405. rcu_assign_pointer(geneve->sock4, NULL);
  1406. if (*gs4)
  1407. rcu_assign_sk_user_data((*gs4)->sock->sk, NULL);
  1408. #if IS_ENABLED(CONFIG_IPV6)
  1409. *gs6 = rtnl_dereference(geneve->sock6);
  1410. rcu_assign_pointer(geneve->sock6, NULL);
  1411. if (*gs6)
  1412. rcu_assign_sk_user_data((*gs6)->sock->sk, NULL);
  1413. #else
  1414. *gs6 = NULL;
  1415. #endif
  1416. synchronize_net();
  1417. }
  1418. /* Resumes the geneve device data path for both TX and RX. */
  1419. static void geneve_unquiesce(struct geneve_dev *geneve, struct geneve_sock *gs4,
  1420. struct geneve_sock __maybe_unused *gs6)
  1421. {
  1422. rcu_assign_pointer(geneve->sock4, gs4);
  1423. if (gs4)
  1424. rcu_assign_sk_user_data(gs4->sock->sk, gs4);
  1425. #if IS_ENABLED(CONFIG_IPV6)
  1426. rcu_assign_pointer(geneve->sock6, gs6);
  1427. if (gs6)
  1428. rcu_assign_sk_user_data(gs6->sock->sk, gs6);
  1429. #endif
  1430. synchronize_net();
  1431. }
  1432. static int geneve_changelink(struct net_device *dev, struct nlattr *tb[],
  1433. struct nlattr *data[],
  1434. struct netlink_ext_ack *extack)
  1435. {
  1436. struct geneve_dev *geneve = netdev_priv(dev);
  1437. struct geneve_sock *gs4, *gs6;
  1438. struct geneve_config cfg;
  1439. int err;
  1440. /* If the geneve device is configured for metadata (or externally
  1441. * controlled, for example, OVS), then nothing can be changed.
  1442. */
  1443. if (geneve->cfg.collect_md)
  1444. return -EOPNOTSUPP;
  1445. /* Start with the existing info. */
  1446. memcpy(&cfg, &geneve->cfg, sizeof(cfg));
  1447. err = geneve_nl2info(tb, data, extack, &cfg, true);
  1448. if (err)
  1449. return err;
  1450. if (!geneve_dst_addr_equal(&geneve->cfg.info, &cfg.info)) {
  1451. dst_cache_reset(&cfg.info.dst_cache);
  1452. geneve_link_config(dev, &cfg.info, tb);
  1453. }
  1454. geneve_quiesce(geneve, &gs4, &gs6);
  1455. memcpy(&geneve->cfg, &cfg, sizeof(cfg));
  1456. geneve_unquiesce(geneve, gs4, gs6);
  1457. return 0;
  1458. }
  1459. static void geneve_dellink(struct net_device *dev, struct list_head *head)
  1460. {
  1461. struct geneve_dev *geneve = netdev_priv(dev);
  1462. list_del(&geneve->next);
  1463. unregister_netdevice_queue(dev, head);
  1464. }
  1465. static size_t geneve_get_size(const struct net_device *dev)
  1466. {
  1467. return nla_total_size(sizeof(__u32)) + /* IFLA_GENEVE_ID */
  1468. nla_total_size(sizeof(struct in6_addr)) + /* IFLA_GENEVE_REMOTE{6} */
  1469. nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_TTL */
  1470. nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_TOS */
  1471. nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_DF */
  1472. nla_total_size(sizeof(__be32)) + /* IFLA_GENEVE_LABEL */
  1473. nla_total_size(sizeof(__be16)) + /* IFLA_GENEVE_PORT */
  1474. nla_total_size(0) + /* IFLA_GENEVE_COLLECT_METADATA */
  1475. nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_UDP_CSUM */
  1476. nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_UDP_ZERO_CSUM6_TX */
  1477. nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_UDP_ZERO_CSUM6_RX */
  1478. nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_TTL_INHERIT */
  1479. 0;
  1480. }
  1481. static int geneve_fill_info(struct sk_buff *skb, const struct net_device *dev)
  1482. {
  1483. struct geneve_dev *geneve = netdev_priv(dev);
  1484. struct ip_tunnel_info *info = &geneve->cfg.info;
  1485. bool ttl_inherit = geneve->cfg.ttl_inherit;
  1486. bool metadata = geneve->cfg.collect_md;
  1487. __u8 tmp_vni[3];
  1488. __u32 vni;
  1489. tunnel_id_to_vni(info->key.tun_id, tmp_vni);
  1490. vni = (tmp_vni[0] << 16) | (tmp_vni[1] << 8) | tmp_vni[2];
  1491. if (nla_put_u32(skb, IFLA_GENEVE_ID, vni))
  1492. goto nla_put_failure;
  1493. if (!metadata && ip_tunnel_info_af(info) == AF_INET) {
  1494. if (nla_put_in_addr(skb, IFLA_GENEVE_REMOTE,
  1495. info->key.u.ipv4.dst))
  1496. goto nla_put_failure;
  1497. if (nla_put_u8(skb, IFLA_GENEVE_UDP_CSUM,
  1498. !!(info->key.tun_flags & TUNNEL_CSUM)))
  1499. goto nla_put_failure;
  1500. #if IS_ENABLED(CONFIG_IPV6)
  1501. } else if (!metadata) {
  1502. if (nla_put_in6_addr(skb, IFLA_GENEVE_REMOTE6,
  1503. &info->key.u.ipv6.dst))
  1504. goto nla_put_failure;
  1505. if (nla_put_u8(skb, IFLA_GENEVE_UDP_ZERO_CSUM6_TX,
  1506. !(info->key.tun_flags & TUNNEL_CSUM)))
  1507. goto nla_put_failure;
  1508. #endif
  1509. }
  1510. if (nla_put_u8(skb, IFLA_GENEVE_TTL, info->key.ttl) ||
  1511. nla_put_u8(skb, IFLA_GENEVE_TOS, info->key.tos) ||
  1512. nla_put_be32(skb, IFLA_GENEVE_LABEL, info->key.label))
  1513. goto nla_put_failure;
  1514. if (nla_put_u8(skb, IFLA_GENEVE_DF, geneve->cfg.df))
  1515. goto nla_put_failure;
  1516. if (nla_put_be16(skb, IFLA_GENEVE_PORT, info->key.tp_dst))
  1517. goto nla_put_failure;
  1518. if (metadata && nla_put_flag(skb, IFLA_GENEVE_COLLECT_METADATA))
  1519. goto nla_put_failure;
  1520. #if IS_ENABLED(CONFIG_IPV6)
  1521. if (nla_put_u8(skb, IFLA_GENEVE_UDP_ZERO_CSUM6_RX,
  1522. !geneve->cfg.use_udp6_rx_checksums))
  1523. goto nla_put_failure;
  1524. #endif
  1525. if (nla_put_u8(skb, IFLA_GENEVE_TTL_INHERIT, ttl_inherit))
  1526. goto nla_put_failure;
  1527. return 0;
  1528. nla_put_failure:
  1529. return -EMSGSIZE;
  1530. }
  1531. static struct rtnl_link_ops geneve_link_ops __read_mostly = {
  1532. .kind = "geneve",
  1533. .maxtype = IFLA_GENEVE_MAX,
  1534. .policy = geneve_policy,
  1535. .priv_size = sizeof(struct geneve_dev),
  1536. .setup = geneve_setup,
  1537. .validate = geneve_validate,
  1538. .newlink = geneve_newlink,
  1539. .changelink = geneve_changelink,
  1540. .dellink = geneve_dellink,
  1541. .get_size = geneve_get_size,
  1542. .fill_info = geneve_fill_info,
  1543. };
  1544. struct net_device *geneve_dev_create_fb(struct net *net, const char *name,
  1545. u8 name_assign_type, u16 dst_port)
  1546. {
  1547. struct nlattr *tb[IFLA_MAX + 1];
  1548. struct net_device *dev;
  1549. LIST_HEAD(list_kill);
  1550. int err;
  1551. struct geneve_config cfg = {
  1552. .df = GENEVE_DF_UNSET,
  1553. .use_udp6_rx_checksums = true,
  1554. .ttl_inherit = false,
  1555. .collect_md = true,
  1556. };
  1557. memset(tb, 0, sizeof(tb));
  1558. dev = rtnl_create_link(net, name, name_assign_type,
  1559. &geneve_link_ops, tb, NULL);
  1560. if (IS_ERR(dev))
  1561. return dev;
  1562. init_tnl_info(&cfg.info, dst_port);
  1563. err = geneve_configure(net, dev, NULL, &cfg);
  1564. if (err) {
  1565. free_netdev(dev);
  1566. return ERR_PTR(err);
  1567. }
  1568. /* openvswitch users expect packet sizes to be unrestricted,
  1569. * so set the largest MTU we can.
  1570. */
  1571. err = geneve_change_mtu(dev, IP_MAX_MTU);
  1572. if (err)
  1573. goto err;
  1574. err = rtnl_configure_link(dev, NULL);
  1575. if (err < 0)
  1576. goto err;
  1577. return dev;
  1578. err:
  1579. geneve_dellink(dev, &list_kill);
  1580. unregister_netdevice_many(&list_kill);
  1581. return ERR_PTR(err);
  1582. }
  1583. EXPORT_SYMBOL_GPL(geneve_dev_create_fb);
  1584. static int geneve_netdevice_event(struct notifier_block *unused,
  1585. unsigned long event, void *ptr)
  1586. {
  1587. struct net_device *dev = netdev_notifier_info_to_dev(ptr);
  1588. if (event == NETDEV_UDP_TUNNEL_PUSH_INFO ||
  1589. event == NETDEV_UDP_TUNNEL_DROP_INFO) {
  1590. geneve_offload_rx_ports(dev, event == NETDEV_UDP_TUNNEL_PUSH_INFO);
  1591. } else if (event == NETDEV_UNREGISTER) {
  1592. if (!dev->udp_tunnel_nic_info)
  1593. geneve_offload_rx_ports(dev, false);
  1594. } else if (event == NETDEV_REGISTER) {
  1595. if (!dev->udp_tunnel_nic_info)
  1596. geneve_offload_rx_ports(dev, true);
  1597. }
  1598. return NOTIFY_DONE;
  1599. }
  1600. static struct notifier_block geneve_notifier_block __read_mostly = {
  1601. .notifier_call = geneve_netdevice_event,
  1602. };
  1603. static __net_init int geneve_init_net(struct net *net)
  1604. {
  1605. struct geneve_net *gn = net_generic(net, geneve_net_id);
  1606. INIT_LIST_HEAD(&gn->geneve_list);
  1607. INIT_LIST_HEAD(&gn->sock_list);
  1608. return 0;
  1609. }
  1610. static void geneve_destroy_tunnels(struct net *net, struct list_head *head)
  1611. {
  1612. struct geneve_net *gn = net_generic(net, geneve_net_id);
  1613. struct geneve_dev *geneve, *next;
  1614. struct net_device *dev, *aux;
  1615. /* gather any geneve devices that were moved into this ns */
  1616. for_each_netdev_safe(net, dev, aux)
  1617. if (dev->rtnl_link_ops == &geneve_link_ops)
  1618. unregister_netdevice_queue(dev, head);
  1619. /* now gather any other geneve devices that were created in this ns */
  1620. list_for_each_entry_safe(geneve, next, &gn->geneve_list, next) {
  1621. /* If geneve->dev is in the same netns, it was already added
  1622. * to the list by the previous loop.
  1623. */
  1624. if (!net_eq(dev_net(geneve->dev), net))
  1625. unregister_netdevice_queue(geneve->dev, head);
  1626. }
  1627. }
  1628. static void __net_exit geneve_exit_batch_net(struct list_head *net_list)
  1629. {
  1630. struct net *net;
  1631. LIST_HEAD(list);
  1632. rtnl_lock();
  1633. list_for_each_entry(net, net_list, exit_list)
  1634. geneve_destroy_tunnels(net, &list);
  1635. /* unregister the devices gathered above */
  1636. unregister_netdevice_many(&list);
  1637. rtnl_unlock();
  1638. list_for_each_entry(net, net_list, exit_list) {
  1639. const struct geneve_net *gn = net_generic(net, geneve_net_id);
  1640. WARN_ON_ONCE(!list_empty(&gn->sock_list));
  1641. }
  1642. }
  1643. static struct pernet_operations geneve_net_ops = {
  1644. .init = geneve_init_net,
  1645. .exit_batch = geneve_exit_batch_net,
  1646. .id = &geneve_net_id,
  1647. .size = sizeof(struct geneve_net),
  1648. };
  1649. static int __init geneve_init_module(void)
  1650. {
  1651. int rc;
  1652. rc = register_pernet_subsys(&geneve_net_ops);
  1653. if (rc)
  1654. goto out1;
  1655. rc = register_netdevice_notifier(&geneve_notifier_block);
  1656. if (rc)
  1657. goto out2;
  1658. rc = rtnl_link_register(&geneve_link_ops);
  1659. if (rc)
  1660. goto out3;
  1661. return 0;
  1662. out3:
  1663. unregister_netdevice_notifier(&geneve_notifier_block);
  1664. out2:
  1665. unregister_pernet_subsys(&geneve_net_ops);
  1666. out1:
  1667. return rc;
  1668. }
  1669. late_initcall(geneve_init_module);
  1670. static void __exit geneve_cleanup_module(void)
  1671. {
  1672. rtnl_link_unregister(&geneve_link_ops);
  1673. unregister_netdevice_notifier(&geneve_notifier_block);
  1674. unregister_pernet_subsys(&geneve_net_ops);
  1675. }
  1676. module_exit(geneve_cleanup_module);
  1677. MODULE_LICENSE("GPL");
  1678. MODULE_VERSION(GENEVE_NETDEV_VER);
  1679. MODULE_AUTHOR("John W. Linville <linville@tuxdriver.com>");
  1680. MODULE_DESCRIPTION("Interface driver for GENEVE encapsulated traffic");
  1681. MODULE_ALIAS_RTNL_LINK("geneve");