1 /*
2 * Copyright (c) 2019-2021 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28 #if SKYWALK
29
30 #include <sys/param.h>
31 #include <sys/kernel.h>
32 #include <sys/malloc.h>
33 #include <sys/mbuf.h>
34 #include <sys/queue.h>
35 #include <sys/socket.h>
36 #include <sys/sockio.h>
37 #include <sys/sysctl.h>
38 #include <sys/systm.h>
39 #include <sys/kern_event.h>
40 #include <sys/mcache.h>
41 #include <sys/syslog.h>
42
43 #include <net/bpf.h>
44 #include <net/ethernet.h>
45 #include <net/if.h>
46 #include <net/if_vlan_var.h>
47 #include <net/if_arp.h>
48 #include <net/if_dl.h>
49 #include <net/if_ether.h>
50 #include <net/if_types.h>
51 #include <libkern/OSAtomic.h>
52
53 #include <net/dlil.h>
54
55 #include <net/kpi_interface.h>
56 #include <net/kpi_protocol.h>
57
58 #include <kern/locks.h>
59 #include <kern/zalloc.h>
60
61 #ifdef INET
62 #include <netinet/in.h>
63 #include <netinet/if_ether.h>
64 #endif
65
66 #include <net/if_media.h>
67 #include <net/ether_if_module.h>
68 #include <skywalk/os_skywalk_private.h>
69 #include <skywalk/nexus/netif/nx_netif.h>
70 #include <skywalk/channel/channel_var.h>
71
72 static boolean_t
is_power_of_two(unsigned int val)73 is_power_of_two(unsigned int val)
74 {
75 return (val & (val - 1)) == 0;
76 }
77
78 #define HEADLESS_ZERO_IFNAME "zero"
79 #define HEADLESS_NULL_IFNAME "null"
80
81 SYSCTL_DECL(_net_link);
82 SYSCTL_NODE(_net_link, OID_AUTO, headless, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
83 "headless interface");
84
85 static int if_headless_nxattach = 0;
86 SYSCTL_INT(_net_link_headless, OID_AUTO, nxattach,
87 CTLFLAG_RW | CTLFLAG_LOCKED, &if_headless_nxattach, 0,
88 "headless interface auto-attach nexus");
89
90 static int if_headless_debug = 0;
91 SYSCTL_INT(_net_link_headless, OID_AUTO, debug,
92 CTLFLAG_RW | CTLFLAG_LOCKED, &if_headless_debug, 0,
93 "headless interface debug logs");
94
95 static int if_headless_multibuflet = 0;
96 SYSCTL_INT(_net_link_headless, OID_AUTO, multibuflet,
97 CTLFLAG_RW | CTLFLAG_LOCKED, &if_headless_multibuflet, 0,
98 "headless interface using multi-buflet packets");
99
100 static int if_headless_packet_length = 1500;
101 SYSCTL_INT(_net_link_headless, OID_AUTO, packet_length,
102 CTLFLAG_RW | CTLFLAG_LOCKED, &if_headless_packet_length, 0,
103 "headless interface packet length");
104
105 static int if_headless_create_payload = 0;
106 SYSCTL_INT(_net_link_headless, OID_AUTO, create_payload,
107 CTLFLAG_RW | CTLFLAG_LOCKED, &if_headless_create_payload, 0,
108 "headless interface create payload data or not");
109
110 /*
111 * SIOCSDRVSPEC
112 */
113 enum {
114 IF_HEADLESS_S_CMD_NONE = 0,
115 IF_HEADLESS_S_CMD_SET_MEDIA = 1,
116 };
117
118 #define IF_HEADLESS_MEDIA_LIST_MAX 27
119
120 struct if_headless_media {
121 int32_t iffm_current;
122 uint32_t iffm_count;
123 uint32_t iffm_reserved[3];
124 int32_t iffm_list[IF_HEADLESS_MEDIA_LIST_MAX];
125 };
126
127 struct if_headless_request {
128 uint64_t iffr_reserved[4];
129 union {
130 char iffru_buf[128]; /* stable size */
131 struct if_headless_media iffru_media;
132 } iffr_u;
133 #define iffr_media iffr_u.iffru_media
134 };
135
136 /* sysctl net.link.headless.tx_headroom */
137 #define headless_TX_HEADROOM_MAX 32
138 static uint16_t if_headless_tx_headroom = 0;
139
140 extern void if_headless_init(void);
141
142 static int
143 headless_tx_headroom_sysctl SYSCTL_HANDLER_ARGS
144 {
145 #pragma unused(oidp, arg1, arg2)
146 uint16_t new_value;
147 int changed;
148 int error;
149
150 error = sysctl_io_number(req, if_headless_tx_headroom,
151 sizeof(if_headless_tx_headroom), &new_value, &changed);
152 if (error == 0 && changed != 0) {
153 if (new_value > headless_TX_HEADROOM_MAX ||
154 (new_value % 8) != 0) {
155 return EINVAL;
156 }
157 if_headless_tx_headroom = new_value;
158 }
159 return 0;
160 }
161
162 SYSCTL_PROC(_net_link_headless, OID_AUTO, tx_headroom,
163 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
164 0, 0, headless_tx_headroom_sysctl, "IU", "headless ethernet Tx headroom");
165
166 /* sysctl net.link.headless.max_mtu */
167 #define headless_MAX_MTU_DEFAULT 2048
168 #define headless_MAX_MTU_MAX ((16 * 1024) - ETHER_HDR_LEN)
169
170 static unsigned int if_headless_max_mtu = headless_MAX_MTU_DEFAULT;
171
172 /* sysctl net.link.headless.buflet_size */
173 #define headless_BUFLET_SIZE_MIN 512
174 #define headless_BUFLET_SIZE_MAX 2048
175
176 static unsigned int if_headless_buflet_size = headless_BUFLET_SIZE_MIN;
177
178 static int
179 headless_max_mtu_sysctl SYSCTL_HANDLER_ARGS
180 {
181 #pragma unused(oidp, arg1, arg2)
182 unsigned int new_value;
183 int changed;
184 int error;
185
186 error = sysctl_io_number(req, if_headless_max_mtu,
187 sizeof(if_headless_max_mtu), &new_value, &changed);
188 if (error == 0 && changed != 0) {
189 if (new_value > headless_MAX_MTU_MAX ||
190 new_value < ETHERMTU ||
191 new_value <= if_headless_buflet_size) {
192 return EINVAL;
193 }
194 if_headless_max_mtu = new_value;
195 }
196 return 0;
197 }
198
199 SYSCTL_PROC(_net_link_headless, OID_AUTO, max_mtu,
200 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
201 0, 0, headless_max_mtu_sysctl, "IU", "headless interface maximum MTU");
202
203 static int
204 headless_buflet_size_sysctl SYSCTL_HANDLER_ARGS
205 {
206 #pragma unused(oidp, arg1, arg2)
207 unsigned int new_value;
208 int changed;
209 int error;
210
211 error = sysctl_io_number(req, if_headless_buflet_size,
212 sizeof(if_headless_buflet_size), &new_value, &changed);
213 if (error == 0 && changed != 0) {
214 /* must be a power of 2 between min and max */
215 if (new_value > headless_BUFLET_SIZE_MAX ||
216 new_value < headless_BUFLET_SIZE_MIN ||
217 !is_power_of_two(new_value) ||
218 new_value >= if_headless_max_mtu) {
219 return EINVAL;
220 }
221 if_headless_buflet_size = new_value;
222 }
223 return 0;
224 }
225
226 SYSCTL_PROC(_net_link_headless, OID_AUTO, buflet_size,
227 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
228 0, 0, headless_buflet_size_sysctl, "IU", "headless interface buflet size");
229
230 /**
231 ** virtual ethernet structures, types
232 **/
233
234 #define IFF_NUM_TX_RINGS_WMM_MODE 4
235 #define IFF_NUM_RX_RINGS_WMM_MODE 1
236 #define IFF_MAX_TX_RINGS IFF_NUM_TX_RINGS_WMM_MODE
237 #define IFF_MAX_RX_RINGS IFF_NUM_RX_RINGS_WMM_MODE
238
239 typedef uint16_t iff_flags_t;
240 #define IFF_FLAGS_HWCSUM 0x0001
241 #define IFF_FLAGS_BSD_MODE 0x0002
242 #define IFF_FLAGS_DETACHING 0x0004
243 #define IFF_FLAGS_WMM_MODE 0x0008
244 #define IFF_FLAGS_MULTIBUFLETS 0x0010
245 #define IFF_FLAGS_COPYPKT_MODE 0x0020
246
247 typedef struct {
248 kern_pbufpool_t fpp_pp;
249 uint32_t fpp_retain_count;
250 } headless_packet_pool, *headless_packet_pool_t;
251
252 typedef struct {
253 uuid_t fnx_provider;
254 uuid_t fnx_instance;
255 } headless_nx, *headless_nx_t;
256
257 struct if_headless {
258 struct if_clone * iff_cloner;
259 char iff_name[IFNAMSIZ]; /* our unique id */
260 ifnet_t iff_ifp;
261 iff_flags_t iff_flags;
262 uint32_t iff_retain_count;
263 ifnet_t iff_peer; /* the other end */
264 int iff_media_current;
265 int iff_media_active;
266 uint32_t iff_media_count;
267 int iff_media_list[IF_HEADLESS_MEDIA_LIST_MAX];
268 struct mbuf * iff_pending_tx_packet;
269 boolean_t iff_start_busy;
270 unsigned int iff_max_mtu;
271 headless_nx iff_nx;
272 kern_channel_ring_t iff_rx_ring[IFF_MAX_RX_RINGS];
273 kern_channel_ring_t iff_tx_ring[IFF_MAX_TX_RINGS];
274 thread_call_t iff_doorbell_tcall;
275 boolean_t iff_tcall_active;
276 boolean_t iff_waiting_for_tcall;
277 boolean_t iff_channel_connected;
278 headless_packet_pool_t iff_fpp;
279 uint16_t iff_tx_headroom;
280 };
281
282 typedef struct if_headless * if_headless_ref;
283
284 static if_headless_ref
285 ifnet_get_if_headless(ifnet_t ifp);
286
287 #define HEADLESS_DPRINTF(fmt, ...) \
288 { if (if_headless_debug != 0) printf("%s " fmt, __func__, ## __VA_ARGS__); }
289
290 static inline void
headless_set_detaching(if_headless_ref headlessif)291 headless_set_detaching(if_headless_ref headlessif)
292 {
293 headlessif->iff_flags |= IFF_FLAGS_DETACHING;
294 }
295
296 static inline boolean_t
headless_is_detaching(if_headless_ref headlessif)297 headless_is_detaching(if_headless_ref headlessif)
298 {
299 return (headlessif->iff_flags & IFF_FLAGS_DETACHING) != 0;
300 }
301
302 static inline boolean_t
headless_using_multibuflets(if_headless_ref headlessif)303 headless_using_multibuflets(if_headless_ref headlessif)
304 {
305 return (headlessif->iff_flags & IFF_FLAGS_MULTIBUFLETS) != 0;
306 }
307
308 #define HEADLESS_MAXUNIT IF_MAXUNIT
309 #define HEADLESS_ZONE_MAX_ELEM MIN(IFNETS_MAX, HEADLESS_MAXUNIT)
310
311 static int headless_clone_create(struct if_clone *, u_int32_t, void *);
312 static int headless_clone_destroy(ifnet_t);
313 static int headless_ioctl(ifnet_t ifp, u_long cmd, void * addr);
314 static void headless_if_free(ifnet_t ifp);
315 static void headless_ifnet_set_attrs(if_headless_ref headlessif, ifnet_t ifp);
316 static void headless_free(if_headless_ref headlessif);
317
318 static struct if_clone
319 headless_zero_cloner = IF_CLONE_INITIALIZER(HEADLESS_ZERO_IFNAME,
320 headless_clone_create,
321 headless_clone_destroy,
322 0,
323 HEADLESS_MAXUNIT);
324
325 static struct if_clone
326 headless_null_cloner = IF_CLONE_INITIALIZER(HEADLESS_NULL_IFNAME,
327 headless_clone_create,
328 headless_clone_destroy,
329 0,
330 HEADLESS_MAXUNIT);
331
332 static void interface_link_event(ifnet_t ifp, u_int32_t event_code);
333
334 /* some media words to pretend to be ethernet */
335 static int default_media_words[] = {
336 IFM_MAKEWORD(IFM_ETHER, 0, 0, 0),
337 IFM_MAKEWORD(IFM_ETHER, IFM_10G_T, IFM_FDX, 0),
338 IFM_MAKEWORD(IFM_ETHER, IFM_2500_T, IFM_FDX, 0),
339 IFM_MAKEWORD(IFM_ETHER, IFM_5000_T, IFM_FDX, 0),
340 };
341 #define default_media_words_count (sizeof(default_media_words) \
342 / sizeof (default_media_words[0]))
343
344 /**
345 ** veth locks
346 **/
347
348 static LCK_GRP_DECLARE(headless_lck_grp, "headless");
349 static LCK_MTX_DECLARE(headless_lck_mtx, &headless_lck_grp);
350
351 static inline void
headless_lock(void)352 headless_lock(void)
353 {
354 lck_mtx_lock(&headless_lck_mtx);
355 }
356
357 static inline void
headless_unlock(void)358 headless_unlock(void)
359 {
360 lck_mtx_unlock(&headless_lck_mtx);
361 }
362
363 static inline unsigned int
headless_max_mtu(ifnet_t ifp)364 headless_max_mtu(ifnet_t ifp)
365 {
366 if_headless_ref headlessif;
367 unsigned int max_mtu = ETHERMTU;
368
369 headless_lock();
370 headlessif = ifnet_get_if_headless(ifp);
371 if (headlessif != NULL) {
372 max_mtu = headlessif->iff_max_mtu;
373 }
374 headless_unlock();
375 return max_mtu;
376 }
377
378 static void
headless_packet_pool_free(headless_packet_pool_t fpp)379 headless_packet_pool_free(headless_packet_pool_t fpp)
380 {
381 kern_pbufpool_destroy(fpp->fpp_pp);
382 kfree_type(headless_packet_pool, fpp);
383 }
384
385 static void
headless_free(if_headless_ref headlessif)386 headless_free(if_headless_ref headlessif)
387 {
388 assert(headlessif->iff_retain_count == 0);
389 if (headlessif->iff_fpp != NULL) {
390 headless_packet_pool_free(headlessif->iff_fpp);
391 }
392
393 HEADLESS_DPRINTF("%s\n", headlessif->iff_name);
394 kfree_type(struct if_headless, headlessif);
395 }
396
397 static void
headless_release(if_headless_ref headlessif)398 headless_release(if_headless_ref headlessif)
399 {
400 u_int32_t old_retain_count;
401
402 old_retain_count = OSDecrementAtomic(&headlessif->iff_retain_count);
403 switch (old_retain_count) {
404 case 0:
405 assert(old_retain_count != 0);
406 break;
407 case 1:
408 headless_free(headlessif);
409 break;
410 default:
411 break;
412 }
413 return;
414 }
415
416 static void
headless_retain(if_headless_ref headlessif)417 headless_retain(if_headless_ref headlessif)
418 {
419 OSIncrementAtomic(&headlessif->iff_retain_count);
420 }
421
422 static void
headless_seg_ctor_fn(const kern_pbufpool_t pp,const kern_segment_t buf_seg,const IOSKMemoryDescriptor buf_desc)423 headless_seg_ctor_fn(const kern_pbufpool_t pp, const kern_segment_t buf_seg,
424 const IOSKMemoryDescriptor buf_desc)
425 {
426 #pragma unused(pp, buf_seg, buf_desc)
427 }
428
429 static void
headless_seg_dtor_fn(const kern_pbufpool_t pp,const kern_segment_t buf_seg,const IOSKMemoryDescriptor buf_desc)430 headless_seg_dtor_fn(const kern_pbufpool_t pp, const kern_segment_t buf_seg,
431 const IOSKMemoryDescriptor buf_desc)
432 {
433 #pragma unused(pp, buf_seg, buf_desc)
434 }
435
436 static headless_packet_pool_t
headless_packet_pool_alloc(boolean_t multi_buflet,unsigned int max_mtu)437 headless_packet_pool_alloc(boolean_t multi_buflet, unsigned int max_mtu)
438 {
439 headless_packet_pool_t fpp = NULL;
440 errno_t error;
441 struct kern_pbufpool * pp;
442 struct kern_pbufpool_init pp_init;
443
444 bzero(&pp_init, sizeof(pp_init));
445 pp_init.kbi_version = KERN_PBUFPOOL_CURRENT_VERSION;
446 pp_init.kbi_flags |= KBIF_USER_ACCESS;
447 pp_init.kbi_flags |= KBIF_VIRTUAL_DEVICE;
448 (void)snprintf((char *)pp_init.kbi_name, sizeof(pp_init.kbi_name),
449 "%s", "headless ethernet");
450 pp_init.kbi_packets = 4096; /* XXX make this configurable */
451 if (multi_buflet) {
452 pp_init.kbi_bufsize = if_headless_buflet_size;
453 pp_init.kbi_max_frags = howmany(max_mtu, if_headless_buflet_size);
454 pp_init.kbi_buflets = pp_init.kbi_packets *
455 pp_init.kbi_max_frags;
456 pp_init.kbi_flags |= KBIF_BUFFER_ON_DEMAND;
457 } else {
458 pp_init.kbi_bufsize = max_mtu;
459 pp_init.kbi_max_frags = 1;
460 pp_init.kbi_buflets = pp_init.kbi_packets;
461 }
462 pp_init.kbi_buf_seg_size = skmem_usr_buf_seg_size;
463 if (skywalk_netif_direct_enabled()) {
464 pp_init.kbi_flags |= KBIF_USER_ACCESS;
465 }
466 pp_init.kbi_buf_seg_ctor = headless_seg_ctor_fn;
467 pp_init.kbi_buf_seg_dtor = headless_seg_dtor_fn;
468 pp_init.kbi_ctx = NULL;
469 pp_init.kbi_ctx_retain = NULL;
470 pp_init.kbi_ctx_release = NULL;
471
472 error = kern_pbufpool_create(&pp_init, &pp, NULL);
473 if (error != 0) {
474 printf("%s: kern_pbufpool_create failed %d\n", __func__, error);
475 } else {
476 fpp = kalloc_type(headless_packet_pool, Z_WAITOK | Z_ZERO);
477 fpp->fpp_pp = pp;
478 fpp->fpp_retain_count = 1;
479 }
480 return fpp;
481 }
482
483 /**
484 ** nexus netif domain provider
485 **/
486 static errno_t
headless_nxdp_init(kern_nexus_domain_provider_t domprov)487 headless_nxdp_init(kern_nexus_domain_provider_t domprov)
488 {
489 #pragma unused(domprov)
490 return 0;
491 }
492
493 static void
headless_nxdp_fini(kern_nexus_domain_provider_t domprov)494 headless_nxdp_fini(kern_nexus_domain_provider_t domprov)
495 {
496 #pragma unused(domprov)
497 }
498
499 static uuid_t headless_nx_dom_prov;
500
501 static errno_t
headless_register_nexus_domain_provider(void)502 headless_register_nexus_domain_provider(void)
503 {
504 const struct kern_nexus_domain_provider_init dp_init = {
505 .nxdpi_version = KERN_NEXUS_DOMAIN_PROVIDER_CURRENT_VERSION,
506 .nxdpi_flags = 0,
507 .nxdpi_init = headless_nxdp_init,
508 .nxdpi_fini = headless_nxdp_fini
509 };
510 errno_t err = 0;
511
512 /* headless_nxdp_init() is called before this function returns */
513 err = kern_nexus_register_domain_provider(NEXUS_TYPE_NET_IF,
514 (const uint8_t *)
515 "com.apple.headless",
516 &dp_init, sizeof(dp_init),
517 &headless_nx_dom_prov);
518 if (err != 0) {
519 printf("%s: failed to register domain provider\n", __func__);
520 return err;
521 }
522 return 0;
523 }
524
525 /**
526 ** netif nexus routines
527 **/
528 static if_headless_ref
headless_nexus_context(kern_nexus_t nexus)529 headless_nexus_context(kern_nexus_t nexus)
530 {
531 if_headless_ref headlessif;
532
533 headlessif = (if_headless_ref)kern_nexus_get_context(nexus);
534 assert(headlessif != NULL);
535 return headlessif;
536 }
537
538 static errno_t
headless_nx_ring_init(kern_nexus_provider_t nxprov,kern_nexus_t nexus,kern_channel_t channel,kern_channel_ring_t ring,boolean_t is_tx_ring,void ** ring_ctx)539 headless_nx_ring_init(kern_nexus_provider_t nxprov, kern_nexus_t nexus,
540 kern_channel_t channel, kern_channel_ring_t ring, boolean_t is_tx_ring,
541 void **ring_ctx)
542 {
543 if_headless_ref headlessif;
544 #pragma unused(nxprov, channel, ring_ctx)
545 headless_lock();
546 headlessif = headless_nexus_context(nexus);
547 if (headless_is_detaching(headlessif)) {
548 headless_unlock();
549 return 0;
550 }
551 if (is_tx_ring) {
552 assert(headlessif->iff_tx_ring[0] == NULL);
553 headlessif->iff_tx_ring[0] = ring;
554 } else {
555 assert(headlessif->iff_rx_ring[0] == NULL);
556 headlessif->iff_rx_ring[0] = ring;
557 }
558 headless_unlock();
559 HEADLESS_DPRINTF("%s: %s ring init\n",
560 headlessif->iff_name, is_tx_ring ? "TX" : "RX");
561 return 0;
562 }
563
564 static void
headless_nx_ring_fini(kern_nexus_provider_t nxprov,kern_nexus_t nexus,kern_channel_ring_t ring)565 headless_nx_ring_fini(kern_nexus_provider_t nxprov, kern_nexus_t nexus,
566 kern_channel_ring_t ring)
567 {
568 #pragma unused(nxprov, ring)
569 if_headless_ref headlessif;
570 thread_call_t tcall = NULL;
571
572 headless_lock();
573 headlessif = headless_nexus_context(nexus);
574 if (headlessif->iff_rx_ring[0] == ring) {
575 headlessif->iff_rx_ring[0] = NULL;
576 HEADLESS_DPRINTF("%s: RX ring fini\n", headlessif->iff_name);
577 } else if (headlessif->iff_tx_ring[0] == ring) {
578 tcall = headlessif->iff_doorbell_tcall;
579 headlessif->iff_doorbell_tcall = NULL;
580 headlessif->iff_tx_ring[0] = NULL;
581 }
582 headless_unlock();
583 if (tcall != NULL) {
584 boolean_t success;
585
586 success = thread_call_cancel_wait(tcall);
587 HEADLESS_DPRINTF("%s: thread_call_cancel %s\n",
588 headlessif->iff_name,
589 success ? "SUCCESS" : "FAILURE");
590 if (!success) {
591 headless_lock();
592 if (headlessif->iff_tcall_active) {
593 headlessif->iff_waiting_for_tcall = TRUE;
594 HEADLESS_DPRINTF("%s: *waiting for threadcall\n",
595 headlessif->iff_name);
596 do {
597 msleep(headlessif, &headless_lck_mtx,
598 PZERO, "headless threadcall", 0);
599 } while (headlessif->iff_tcall_active);
600 HEADLESS_DPRINTF("%s: ^threadcall done\n",
601 headlessif->iff_name);
602 headlessif->iff_waiting_for_tcall = FALSE;
603 }
604 headless_unlock();
605 }
606 success = thread_call_free(tcall);
607 HEADLESS_DPRINTF("%s: thread_call_free %s\n",
608 headlessif->iff_name,
609 success ? "SUCCESS" : "FAILURE");
610 headless_release(headlessif);
611 assert(success == TRUE);
612 }
613 }
614
615 static errno_t
headless_nx_pre_connect(kern_nexus_provider_t nxprov,proc_t proc,kern_nexus_t nexus,nexus_port_t port,kern_channel_t channel,void ** channel_context)616 headless_nx_pre_connect(kern_nexus_provider_t nxprov,
617 proc_t proc, kern_nexus_t nexus, nexus_port_t port, kern_channel_t channel,
618 void **channel_context)
619 {
620 #pragma unused(nxprov, proc, nexus, port, channel, channel_context)
621 return 0;
622 }
623
624 static errno_t
headless_nx_connected(kern_nexus_provider_t nxprov,kern_nexus_t nexus,kern_channel_t channel)625 headless_nx_connected(kern_nexus_provider_t nxprov,
626 kern_nexus_t nexus, kern_channel_t channel)
627 {
628 #pragma unused(nxprov, channel)
629 if_headless_ref headlessif;
630
631 headlessif = headless_nexus_context(nexus);
632 headless_lock();
633 if (headless_is_detaching(headlessif)) {
634 headless_unlock();
635 return EBUSY;
636 }
637 headless_retain(headlessif);
638 headlessif->iff_channel_connected = TRUE;
639 headless_unlock();
640 HEADLESS_DPRINTF("%s: connected channel %p\n",
641 headlessif->iff_name, channel);
642 return 0;
643 }
644
645 static void
headless_nx_pre_disconnect(kern_nexus_provider_t nxprov,kern_nexus_t nexus,kern_channel_t channel)646 headless_nx_pre_disconnect(kern_nexus_provider_t nxprov,
647 kern_nexus_t nexus, kern_channel_t channel)
648 {
649 #pragma unused(nxprov, channel)
650 if_headless_ref headlessif;
651
652 headlessif = headless_nexus_context(nexus);
653 HEADLESS_DPRINTF("%s: pre-disconnect channel %p\n",
654 headlessif->iff_name, channel);
655 /* Quiesce the interface and flush any pending outbound packets. */
656 if_down(headlessif->iff_ifp);
657 headless_lock();
658 headlessif->iff_channel_connected = FALSE;
659 headless_unlock();
660 }
661
662 static void
headless_nx_disconnected(kern_nexus_provider_t nxprov,kern_nexus_t nexus,kern_channel_t channel)663 headless_nx_disconnected(kern_nexus_provider_t nxprov,
664 kern_nexus_t nexus, kern_channel_t channel)
665 {
666 #pragma unused(nxprov, channel)
667 if_headless_ref headlessif;
668
669 headlessif = headless_nexus_context(nexus);
670 HEADLESS_DPRINTF("%s: disconnected channel %p\n",
671 headlessif->iff_name, channel);
672 headless_release(headlessif);
673 }
674
675 static errno_t
headless_nx_slot_init(kern_nexus_provider_t nxprov,kern_nexus_t nexus,kern_channel_ring_t ring,kern_channel_slot_t slot,uint32_t slot_index,struct kern_slot_prop ** slot_prop_addr,void ** slot_context)676 headless_nx_slot_init(kern_nexus_provider_t nxprov,
677 kern_nexus_t nexus, kern_channel_ring_t ring, kern_channel_slot_t slot,
678 uint32_t slot_index, struct kern_slot_prop **slot_prop_addr,
679 void **slot_context)
680 {
681 #pragma unused(nxprov, nexus, ring, slot, slot_index, slot_prop_addr, slot_context)
682 return 0;
683 }
684
685 static void
headless_nx_slot_fini(kern_nexus_provider_t nxprov,kern_nexus_t nexus,kern_channel_ring_t ring,kern_channel_slot_t slot,uint32_t slot_index)686 headless_nx_slot_fini(kern_nexus_provider_t nxprov,
687 kern_nexus_t nexus, kern_channel_ring_t ring, kern_channel_slot_t slot,
688 uint32_t slot_index)
689 {
690 #pragma unused(nxprov, nexus, ring, slot, slot_index)
691 }
692
693 static errno_t
headless_nx_sync_tx(kern_nexus_provider_t nxprov,kern_nexus_t nexus,kern_channel_ring_t tx_ring,uint32_t flags)694 headless_nx_sync_tx(kern_nexus_provider_t nxprov,
695 kern_nexus_t nexus, kern_channel_ring_t tx_ring, uint32_t flags)
696 {
697 #pragma unused(nxprov)
698 if_headless_ref headlessif;
699 ifnet_t ifp;
700 kern_channel_slot_t last_tx_slot = NULL;
701 struct kern_channel_ring_stat_increment stats = {
702 .kcrsi_slots_transferred = 0, .kcrsi_bytes_transferred = 0
703 };
704 kern_channel_slot_t tx_slot;
705 struct netif_stats *nifs = &NX_NETIF_PRIVATE(nexus)->nif_stats;
706
707 STATS_INC(nifs, NETIF_STATS_TX_SYNC);
708 headlessif = headless_nexus_context(nexus);
709 HEADLESS_DPRINTF("%s ring %d flags 0x%x\n", headlessif->iff_name,
710 tx_ring->ckr_ring_id, flags);
711
712 headless_lock();
713 if (headless_is_detaching(headlessif) ||
714 !headlessif->iff_channel_connected) {
715 headless_unlock();
716 return 0;
717 }
718 headless_unlock();
719 ifp = headlessif->iff_ifp;
720 tx_slot = kern_channel_get_next_slot(tx_ring, NULL, NULL);
721 while (tx_slot != NULL) {
722 kern_packet_t ph;
723
724 /* detach the packet from the TX ring */
725 ph = kern_channel_slot_get_packet(tx_ring, tx_slot);
726 assert(ph != 0);
727 kern_channel_slot_detach_packet(tx_ring, tx_slot, ph);
728
729 kern_pbufpool_free(headlessif->iff_fpp->fpp_pp, ph);
730 last_tx_slot = tx_slot;
731 tx_slot = kern_channel_get_next_slot(tx_ring, tx_slot, NULL);
732 STATS_INC(nifs, NETIF_STATS_TX_PACKETS);
733 }
734
735 if (last_tx_slot != NULL) {
736 kern_channel_advance_slot(tx_ring, last_tx_slot);
737 kern_channel_increment_ring_net_stats(tx_ring, ifp, &stats);
738 }
739 return 0;
740 }
741
742 static errno_t
headless_nx_sync_rx_null(kern_nexus_provider_t nxprov,kern_nexus_t nexus,kern_channel_ring_t rx_ring,uint32_t flags)743 headless_nx_sync_rx_null(kern_nexus_provider_t nxprov,
744 kern_nexus_t nexus, kern_channel_ring_t rx_ring, uint32_t flags)
745 {
746 #pragma unused(nxprov, rx_ring, flags)
747 if_headless_ref headlessif;
748 struct netif_stats *nifs = &NX_NETIF_PRIVATE(nexus)->nif_stats;
749
750 headlessif = headless_nexus_context(nexus);
751 HEADLESS_DPRINTF("%s:\n", headlessif->iff_name);
752 STATS_INC(nifs, NETIF_STATS_RX_SYNC);
753 return 0;
754 }
755
756 static errno_t
headless_nx_sync_rx(kern_nexus_provider_t nxprov,kern_nexus_t nexus,kern_channel_ring_t rx_ring,uint32_t flags)757 headless_nx_sync_rx(kern_nexus_provider_t nxprov,
758 kern_nexus_t nexus, kern_channel_ring_t rx_ring, uint32_t flags)
759 {
760 #pragma unused(nxprov)
761 if_headless_ref headlessif;
762 ifnet_t ifp;
763 kern_channel_slot_t last_rx_slot = NULL;
764 struct kern_channel_ring_stat_increment stats = {
765 .kcrsi_slots_transferred = 0, .kcrsi_bytes_transferred = 0
766 };
767 kern_channel_slot_t rx_slot;
768 struct netif_stats *nifs = &NX_NETIF_PRIVATE(nexus)->nif_stats;
769
770 kern_channel_reclaim(rx_ring);
771 STATS_INC(nifs, NETIF_STATS_RX_SYNC);
772 headlessif = headless_nexus_context(nexus);
773 HEADLESS_DPRINTF("%s ring %d flags 0x%x\n", headlessif->iff_name,
774 rx_ring->ckr_ring_id, flags);
775
776 headless_lock();
777 if (headless_is_detaching(headlessif) ||
778 !headlessif->iff_channel_connected) {
779 headless_unlock();
780 return 0;
781 }
782 headless_unlock();
783 ifp = headlessif->iff_ifp;
784 rx_slot = kern_channel_get_next_slot(rx_ring, NULL, NULL);
785 kern_pbufpool_t pp = headlessif->iff_fpp->fpp_pp;
786 while (rx_slot != NULL) {
787 kern_packet_t ph;
788 kern_buflet_t buf = NULL;
789 int err;
790 err = kern_pbufpool_alloc(pp, 1, &ph);
791 buf = kern_packet_get_next_buflet(ph, buf);
792 kern_buflet_set_data_offset(buf, 0);
793 if (if_headless_create_payload) {
794 // This is a plain TCP SYN packet
795 void *addr = kern_buflet_get_data_address(buf);
796 uint64_t *u64 = addr;
797 *(u64 + 0) = 0xc100d51dc3355b68ULL;
798 *(u64 + 1) = 0x004500084019c564ULL;
799 *(u64 + 2) = 0x0634004000004000ULL;
800 *(u64 + 3) = 0x716111e3068d11c0ULL;
801 *(u64 + 4) = 0xc0118d06e3116171ULL;
802 *(u64 + 5) = 0x8a3700000000b002ULL;
803 *(u64 + 6) = 0x02b000000000378aULL;
804 *(u64 + 7) = 0x010106030301b405ULL;
805 *(u64 + 8) = 0x000022cc5c940a08ULL;
806 *(u64 + 9) = 0x0000040200000000ULL;
807 }
808 kern_buflet_set_data_length(buf, (uint16_t)if_headless_packet_length);
809 err = kern_packet_set_headroom(ph, 0);
810 ASSERT(err == 0);
811 err = kern_packet_set_link_header_length(ph, 14);
812 ASSERT(err == 0);
813 kern_packet_finalize(ph);
814
815 kern_channel_slot_attach_packet(rx_ring, rx_slot, ph);
816
817 STATS_INC(nifs, NETIF_STATS_RX_PACKETS);
818 last_rx_slot = rx_slot;
819 rx_slot = kern_channel_get_next_slot(rx_ring, rx_slot, NULL);
820 }
821
822 if (last_rx_slot != NULL) {
823 kern_channel_advance_slot(rx_ring, last_rx_slot);
824 kern_channel_increment_ring_net_stats(rx_ring, ifp, &stats);
825 }
826 return 0;
827 }
828
829 static void
headless_async_doorbell(thread_call_param_t arg0,thread_call_param_t arg1)830 headless_async_doorbell(thread_call_param_t arg0, thread_call_param_t arg1)
831 {
832 #pragma unused(arg1)
833 errno_t error;
834 if_headless_ref headlessif = (if_headless_ref)arg0;
835 kern_channel_ring_t ring;
836 boolean_t more;
837
838 headless_lock();
839 ring = headlessif->iff_tx_ring[0];
840 if (headless_is_detaching(headlessif) ||
841 !headlessif->iff_channel_connected ||
842 ring == NULL) {
843 goto done;
844 }
845 headlessif->iff_tcall_active = TRUE;
846 headless_unlock();
847 error = kern_channel_tx_refill(ring, UINT32_MAX,
848 UINT32_MAX, FALSE, &more);
849 if (error != 0) {
850 HEADLESS_DPRINTF("%s: TX refill failed %d\n",
851 headlessif->iff_name, error);
852 } else {
853 HEADLESS_DPRINTF("%s: TX refilled\n", headlessif->iff_name);
854 }
855
856 headless_lock();
857 done:
858 headlessif->iff_tcall_active = FALSE;
859 if (headlessif->iff_waiting_for_tcall) {
860 HEADLESS_DPRINTF("%s: threadcall waking up waiter\n",
861 headlessif->iff_name);
862 wakeup((caddr_t)headlessif);
863 }
864 headless_unlock();
865 }
866
867 static void
headless_schedule_async_doorbell(if_headless_ref headlessif)868 headless_schedule_async_doorbell(if_headless_ref headlessif)
869 {
870 thread_call_t tcall;
871
872 headless_lock();
873 if (headless_is_detaching(headlessif) ||
874 !headlessif->iff_channel_connected) {
875 headless_unlock();
876 return;
877 }
878 tcall = headlessif->iff_doorbell_tcall;
879 if (tcall != NULL) {
880 thread_call_enter(tcall);
881 } else {
882 tcall = thread_call_allocate_with_options(headless_async_doorbell,
883 (thread_call_param_t)headlessif,
884 THREAD_CALL_PRIORITY_KERNEL,
885 THREAD_CALL_OPTIONS_ONCE);
886 if (tcall == NULL) {
887 printf("%s: %s tcall alloc failed\n",
888 __func__, headlessif->iff_name);
889 } else {
890 headlessif->iff_doorbell_tcall = tcall;
891 headless_retain(headlessif);
892 thread_call_enter(tcall);
893 }
894 }
895 headless_unlock();
896 }
897
898 static errno_t
headless_nx_tx_doorbell(kern_nexus_provider_t nxprov,kern_nexus_t nexus,kern_channel_ring_t ring,uint32_t flags)899 headless_nx_tx_doorbell(kern_nexus_provider_t nxprov,
900 kern_nexus_t nexus, kern_channel_ring_t ring, uint32_t flags)
901 {
902 #pragma unused(nxprov, ring, flags)
903 errno_t error;
904 if_headless_ref headlessif;
905
906 headlessif = headless_nexus_context(nexus);
907 HEADLESS_DPRINTF("%s\n", headlessif->iff_name);
908
909 if ((flags & KERN_NEXUS_TXDOORBELLF_ASYNC_REFILL) == 0) {
910 boolean_t more;
911 /* synchronous tx refill */
912 error = kern_channel_tx_refill(ring, UINT32_MAX,
913 UINT32_MAX, TRUE, &more);
914 if (error != 0) {
915 HEADLESS_DPRINTF("%s: TX refill (sync) %d\n",
916 headlessif->iff_name, error);
917 } else {
918 HEADLESS_DPRINTF("%s: TX refilled (sync)\n",
919 headlessif->iff_name);
920 }
921 } else {
922 HEADLESS_DPRINTF("%s: schedule async refill\n",
923 headlessif->iff_name);
924 headless_schedule_async_doorbell(headlessif);
925 }
926 return 0;
927 }
928
929 static errno_t
headless_netif_prepare(kern_nexus_t nexus,ifnet_t ifp)930 headless_netif_prepare(kern_nexus_t nexus, ifnet_t ifp)
931 {
932 if_headless_ref headlessif;
933
934 headlessif = (if_headless_ref)kern_nexus_get_context(nexus);
935 headless_ifnet_set_attrs(headlessif, ifp);
936 return 0;
937 }
938
939 static errno_t
create_netif_provider_and_instance(if_headless_ref headlessif,struct ifnet_init_eparams * init_params,ifnet_t * ifp,uuid_t * provider,uuid_t * instance)940 create_netif_provider_and_instance(if_headless_ref headlessif,
941 struct ifnet_init_eparams * init_params, ifnet_t *ifp,
942 uuid_t * provider, uuid_t * instance)
943 {
944 errno_t err;
945 nexus_controller_t controller = kern_nexus_shared_controller();
946 struct kern_nexus_net_init net_init;
947 nexus_name_t provider_name;
948 nexus_attr_t nexus_attr = NULL;
949 struct kern_nexus_provider_init prov_init = {
950 .nxpi_version = KERN_NEXUS_DOMAIN_PROVIDER_CURRENT_VERSION,
951 .nxpi_flags = NXPIF_VIRTUAL_DEVICE,
952 .nxpi_pre_connect = headless_nx_pre_connect,
953 .nxpi_connected = headless_nx_connected,
954 .nxpi_pre_disconnect = headless_nx_pre_disconnect,
955 .nxpi_disconnected = headless_nx_disconnected,
956 .nxpi_ring_init = headless_nx_ring_init,
957 .nxpi_ring_fini = headless_nx_ring_fini,
958 .nxpi_slot_init = headless_nx_slot_init,
959 .nxpi_slot_fini = headless_nx_slot_fini,
960 .nxpi_sync_tx = headless_nx_sync_tx,
961 .nxpi_sync_rx = headless_nx_sync_rx,
962 .nxpi_tx_doorbell = headless_nx_tx_doorbell,
963 };
964
965 if (headlessif->iff_cloner == &headless_zero_cloner) {
966 prov_init.nxpi_sync_rx = headless_nx_sync_rx;
967 prov_init.nxpi_sync_tx = headless_nx_sync_tx;
968 } else if (headlessif->iff_cloner == &headless_null_cloner) {
969 prov_init.nxpi_sync_rx = headless_nx_sync_rx_null;
970 prov_init.nxpi_sync_tx = headless_nx_sync_tx;
971 }
972
973 _CASSERT(IFF_MAX_RX_RINGS == 1);
974
975 snprintf((char *)provider_name, sizeof(provider_name),
976 "com.apple.netif.%s", headlessif->iff_name);
977 err = kern_nexus_controller_register_provider(controller,
978 headless_nx_dom_prov,
979 provider_name,
980 &prov_init,
981 sizeof(prov_init),
982 nexus_attr,
983 provider);
984 if (err != 0) {
985 printf("%s register provider failed, error %d\n",
986 __func__, err);
987 goto failed;
988 }
989 bzero(&net_init, sizeof(net_init));
990 net_init.nxneti_version = KERN_NEXUS_NET_CURRENT_VERSION;
991 net_init.nxneti_flags = 0;
992 net_init.nxneti_eparams = init_params;
993 net_init.nxneti_lladdr = NULL;
994 net_init.nxneti_prepare = headless_netif_prepare;
995 net_init.nxneti_rx_pbufpool = headlessif->iff_fpp->fpp_pp;
996 net_init.nxneti_tx_pbufpool = headlessif->iff_fpp->fpp_pp;
997 err = kern_nexus_controller_alloc_net_provider_instance(controller,
998 *provider,
999 headlessif,
1000 NULL,
1001 instance,
1002 &net_init,
1003 ifp);
1004 if (err != 0) {
1005 printf("%s alloc_net_provider_instance failed, %d\n",
1006 __func__, err);
1007 kern_nexus_controller_deregister_provider(controller,
1008 *provider);
1009 uuid_clear(*provider);
1010 goto failed;
1011 }
1012
1013 failed:
1014 if (nexus_attr != NULL) {
1015 kern_nexus_attr_destroy(nexus_attr);
1016 }
1017 return err;
1018 }
1019
1020
1021 static errno_t
headless_attach_netif_nexus(if_headless_ref headlessif,struct ifnet_init_eparams * init_params,ifnet_t * ifp)1022 headless_attach_netif_nexus(if_headless_ref headlessif,
1023 struct ifnet_init_eparams * init_params, ifnet_t *ifp)
1024 {
1025 headless_packet_pool_t fpp;
1026 headless_nx_t nx = &headlessif->iff_nx;
1027 boolean_t multi_buflet;
1028
1029 multi_buflet = headless_using_multibuflets(headlessif);
1030 fpp = headless_packet_pool_alloc(multi_buflet, headlessif->iff_max_mtu);
1031 if (fpp == NULL) {
1032 return ENOMEM;
1033 }
1034 headlessif->iff_fpp = fpp;
1035 return create_netif_provider_and_instance(headlessif, init_params, ifp,
1036 &nx->fnx_provider,
1037 &nx->fnx_instance);
1038 }
1039
1040 static void
detach_provider_and_instance(uuid_t provider,uuid_t instance)1041 detach_provider_and_instance(uuid_t provider, uuid_t instance)
1042 {
1043 nexus_controller_t controller = kern_nexus_shared_controller();
1044 errno_t err;
1045
1046 if (!uuid_is_null(instance)) {
1047 err = kern_nexus_controller_free_provider_instance(controller,
1048 instance);
1049 if (err != 0) {
1050 printf("%s free_provider_instance failed %d\n",
1051 __func__, err);
1052 }
1053 uuid_clear(instance);
1054 }
1055 if (!uuid_is_null(provider)) {
1056 err = kern_nexus_controller_deregister_provider(controller,
1057 provider);
1058 if (err != 0) {
1059 printf("%s deregister_provider %d\n", __func__, err);
1060 }
1061 uuid_clear(provider);
1062 }
1063 return;
1064 }
1065
1066 static void
headless_detach_netif_nexus(headless_nx_t nx)1067 headless_detach_netif_nexus(headless_nx_t nx)
1068 {
1069 detach_provider_and_instance(nx->fnx_provider, nx->fnx_instance);
1070 }
1071
1072 /**
1073 ** headless interface routines
1074 **/
1075 static void
headless_ifnet_set_attrs(if_headless_ref headlessif,ifnet_t ifp)1076 headless_ifnet_set_attrs(if_headless_ref headlessif, ifnet_t ifp)
1077 {
1078 (void)ifnet_set_capabilities_enabled(ifp, 0, -1);
1079 ifnet_set_addrlen(ifp, ETHER_ADDR_LEN);
1080 ifnet_set_baudrate(ifp, 0);
1081 ifnet_set_mtu(ifp, ETHERMTU);
1082 ifnet_set_flags(ifp,
1083 IFF_BROADCAST | IFF_MULTICAST | IFF_SIMPLEX,
1084 0xffff);
1085 ifnet_set_hdrlen(ifp, sizeof(struct ether_header));
1086 if ((headlessif->iff_flags & IFF_FLAGS_HWCSUM) != 0) {
1087 ifnet_set_offload(ifp,
1088 IFNET_CSUM_IP | IFNET_CSUM_TCP | IFNET_CSUM_UDP |
1089 IFNET_CSUM_TCPIPV6 | IFNET_CSUM_UDPIPV6);
1090 } else {
1091 ifnet_set_offload(ifp, 0);
1092 }
1093 }
1094
1095 static void
interface_link_event(ifnet_t ifp,u_int32_t event_code)1096 interface_link_event(ifnet_t ifp, u_int32_t event_code)
1097 {
1098 struct event {
1099 u_int32_t ifnet_family;
1100 u_int32_t unit;
1101 char if_name[IFNAMSIZ];
1102 };
1103 _Alignas(struct kern_event_msg) char message[sizeof(struct kern_event_msg) + sizeof(struct event)] = { 0 };
1104 struct kern_event_msg *header = (struct kern_event_msg*)message;
1105 struct event *data = (struct event *)(header + 1);
1106
1107 header->total_size = sizeof(message);
1108 header->vendor_code = KEV_VENDOR_APPLE;
1109 header->kev_class = KEV_NETWORK_CLASS;
1110 header->kev_subclass = KEV_DL_SUBCLASS;
1111 header->event_code = event_code;
1112 data->ifnet_family = ifnet_family(ifp);
1113 data->unit = (u_int32_t)ifnet_unit(ifp);
1114 strlcpy(data->if_name, ifnet_name(ifp), IFNAMSIZ);
1115 ifnet_event(ifp, header);
1116 }
1117
1118 static if_headless_ref
ifnet_get_if_headless(ifnet_t ifp)1119 ifnet_get_if_headless(ifnet_t ifp)
1120 {
1121 return (if_headless_ref)ifnet_softc(ifp);
1122 }
1123
1124 static int
headless_clone_create(struct if_clone * ifc,u_int32_t unit,void * params)1125 headless_clone_create(struct if_clone *ifc, u_int32_t unit, void *params)
1126 {
1127 #pragma unused(params)
1128 int error;
1129 if_headless_ref headlessif;
1130 struct ifnet_init_eparams headless_init;
1131 ifnet_t ifp;
1132 uint8_t mac_address[ETHER_ADDR_LEN];
1133
1134 headlessif = kalloc_type(struct if_headless, Z_WAITOK_ZERO_NOFAIL);
1135 headlessif->iff_retain_count = 1;
1136 if (strcmp(ifc->ifc_name, HEADLESS_ZERO_IFNAME) == 0) {
1137 headlessif->iff_cloner = &headless_zero_cloner;
1138 ASSERT(strlen(HEADLESS_ZERO_IFNAME) == 4);
1139 bcopy(HEADLESS_ZERO_IFNAME, mac_address, 4);
1140 } else {
1141 headlessif->iff_cloner = &headless_null_cloner;
1142 ASSERT(strlen(HEADLESS_NULL_IFNAME) == 4);
1143 bcopy(HEADLESS_NULL_IFNAME, mac_address, 4);
1144 }
1145 mac_address[ETHER_ADDR_LEN - 2] = (unit & 0xff00) >> 8;
1146 mac_address[ETHER_ADDR_LEN - 1] = unit & 0xff;
1147 headlessif->iff_max_mtu = if_headless_max_mtu;
1148
1149 /* use the interface name as the unique id for ifp recycle */
1150 if ((unsigned int)
1151 snprintf(headlessif->iff_name, sizeof(headlessif->iff_name), "%s%d",
1152 ifc->ifc_name, unit) >= sizeof(headlessif->iff_name)) {
1153 headless_release(headlessif);
1154 return EINVAL;
1155 }
1156 bzero(&headless_init, sizeof(headless_init));
1157 headless_init.ver = IFNET_INIT_CURRENT_VERSION;
1158 headless_init.len = sizeof(headless_init);
1159 headless_init.flags |= IFNET_INIT_SKYWALK_NATIVE;
1160 if (if_headless_multibuflet != 0) {
1161 headlessif->iff_flags |= IFF_FLAGS_MULTIBUFLETS;
1162 }
1163
1164 headlessif->iff_tx_headroom = if_headless_tx_headroom;
1165 headless_init.tx_headroom = headlessif->iff_tx_headroom;
1166 if (if_headless_nxattach == 0) {
1167 headless_init.flags |= IFNET_INIT_NX_NOAUTO;
1168 }
1169 headless_init.uniqueid = headlessif->iff_name;
1170 headless_init.uniqueid_len = (uint32_t)strlen(headlessif->iff_name);
1171 headless_init.name = ifc->ifc_name;
1172 headless_init.unit = unit;
1173 headless_init.family = IFNET_FAMILY_ETHERNET;
1174 headless_init.type = IFT_ETHER;
1175 headless_init.demux = ether_demux;
1176 headless_init.add_proto = ether_add_proto;
1177 headless_init.del_proto = ether_del_proto;
1178 headless_init.check_multi = ether_check_multi;
1179 headless_init.framer_extended = ether_frameout_extended;
1180 headless_init.softc = headlessif;
1181 headless_init.ioctl = headless_ioctl;
1182 headless_init.set_bpf_tap = NULL;
1183 headless_init.detach = headless_if_free;
1184 headless_init.broadcast_addr = etherbroadcastaddr;
1185 headless_init.broadcast_len = ETHER_ADDR_LEN;
1186 error = headless_attach_netif_nexus(headlessif, &headless_init, &ifp);
1187 if (error != 0) {
1188 headless_release(headlessif);
1189 return error;
1190 }
1191 /* take an additional reference to ensure that it doesn't go away */
1192 headless_retain(headlessif);
1193 headlessif->iff_ifp = ifp;
1194 headlessif->iff_media_count = default_media_words_count;
1195 bcopy(default_media_words, headlessif->iff_media_list,
1196 sizeof(default_media_words));
1197 ifnet_set_lladdr(ifp, mac_address, sizeof(mac_address));
1198
1199 /* attach as ethernet */
1200 bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header));
1201
1202 interface_link_event(ifp, KEV_DL_LINK_ON);
1203
1204 return 0;
1205 }
1206
1207 static int
headless_clone_destroy(ifnet_t ifp)1208 headless_clone_destroy(ifnet_t ifp)
1209 {
1210 if_headless_ref headlessif;
1211 headless_nx nx;
1212 boolean_t nx_attached = FALSE;
1213
1214 interface_link_event(ifp, KEV_DL_LINK_OFF);
1215 headless_lock();
1216 headlessif = ifnet_get_if_headless(ifp);
1217 if (headlessif == NULL || headless_is_detaching(headlessif)) {
1218 headless_unlock();
1219 return 0;
1220 }
1221 headless_set_detaching(headlessif);
1222 nx_attached = TRUE;
1223 nx = headlessif->iff_nx;
1224 bzero(&headlessif->iff_nx, sizeof(headlessif->iff_nx));
1225 headless_unlock();
1226
1227 if (nx_attached) {
1228 headless_detach_netif_nexus(&nx);
1229 headless_release(headlessif);
1230 }
1231 ifnet_detach(ifp);
1232 return 0;
1233 }
1234
1235 static int
headless_set_media(ifnet_t ifp,struct if_headless_request * iffr)1236 headless_set_media(ifnet_t ifp, struct if_headless_request * iffr)
1237 {
1238 if_headless_ref headlessif;
1239 int error;
1240
1241 if (iffr->iffr_media.iffm_count > IF_HEADLESS_MEDIA_LIST_MAX) {
1242 /* list is too long */
1243 return EINVAL;
1244 }
1245 headless_lock();
1246 headlessif = ifnet_get_if_headless(ifp);
1247 if (headlessif == NULL) {
1248 error = EINVAL;
1249 goto done;
1250 }
1251 headlessif->iff_media_count = iffr->iffr_media.iffm_count;
1252 bcopy(iffr->iffr_media.iffm_list, headlessif->iff_media_list,
1253 iffr->iffr_media.iffm_count * sizeof(headlessif->iff_media_list[0]));
1254 #if 0
1255 /* XXX: "auto-negotiate" active with peer? */
1256 /* generate link status event? */
1257 headlessif->iff_media_current = iffr->iffr_media.iffm_current;
1258 #endif
1259 error = 0;
1260 done:
1261 headless_unlock();
1262 return error;
1263 }
1264
1265 static int
if_headless_request_copyin(user_addr_t user_addr,struct if_headless_request * iffr,size_t len)1266 if_headless_request_copyin(user_addr_t user_addr,
1267 struct if_headless_request *iffr, size_t len)
1268 {
1269 int error;
1270
1271 if (user_addr == USER_ADDR_NULL || len < sizeof(*iffr)) {
1272 error = EINVAL;
1273 goto done;
1274 }
1275 error = copyin(user_addr, iffr, sizeof(*iffr));
1276 if (error != 0) {
1277 goto done;
1278 }
1279 if (iffr->iffr_reserved[0] != 0 || iffr->iffr_reserved[1] != 0 ||
1280 iffr->iffr_reserved[2] != 0 || iffr->iffr_reserved[3] != 0) {
1281 error = EINVAL;
1282 goto done;
1283 }
1284 done:
1285 return error;
1286 }
1287
1288 static int
headless_set_drvspec(ifnet_t ifp,uint64_t cmd,size_t len,user_addr_t user_addr)1289 headless_set_drvspec(ifnet_t ifp, uint64_t cmd, size_t len,
1290 user_addr_t user_addr)
1291 {
1292 int error;
1293 struct if_headless_request iffr;
1294
1295 switch (cmd) {
1296 case IF_HEADLESS_S_CMD_SET_MEDIA:
1297 error = if_headless_request_copyin(user_addr, &iffr, len);
1298 if (error != 0) {
1299 break;
1300 }
1301 error = headless_set_media(ifp, &iffr);
1302 break;
1303 default:
1304 error = EOPNOTSUPP;
1305 break;
1306 }
1307 return error;
1308 }
1309
1310 static int
headless_get_drvspec(ifnet_t ifp,uint64_t cmd,size_t len,user_addr_t user_addr)1311 headless_get_drvspec(ifnet_t ifp, uint64_t cmd, size_t len,
1312 user_addr_t user_addr)
1313 {
1314 #pragma unused(ifp, len, user_addr)
1315 int error = EOPNOTSUPP;
1316
1317 switch (cmd) {
1318 default:
1319 break;
1320 }
1321 return error;
1322 }
1323
1324 union ifdrvu {
1325 struct ifdrv32 *ifdrvu_32;
1326 struct ifdrv64 *ifdrvu_64;
1327 void *ifdrvu_p;
1328 };
1329
1330 static int
headless_ioctl(ifnet_t ifp,u_long cmd,void * data)1331 headless_ioctl(ifnet_t ifp, u_long cmd, void * data)
1332 {
1333 unsigned int count;
1334 struct ifdevmtu * devmtu_p;
1335 union ifdrvu drv;
1336 uint64_t drv_cmd;
1337 uint64_t drv_len;
1338 boolean_t drv_set_command = FALSE;
1339 int error = 0;
1340 struct ifmediareq * ifmr;
1341 struct ifreq * ifr;
1342 if_headless_ref headlessif;
1343 int status;
1344 user_addr_t user_addr;
1345
1346 ifr = (struct ifreq *)data;
1347 switch (cmd) {
1348 case SIOCSIFADDR:
1349 ifnet_set_flags(ifp, IFF_UP, IFF_UP);
1350 break;
1351
1352 case SIOCGIFMEDIA32:
1353 case SIOCGIFMEDIA64:
1354 headless_lock();
1355 headlessif = ifnet_get_if_headless(ifp);
1356 if (headlessif == NULL) {
1357 headless_unlock();
1358 return EOPNOTSUPP;
1359 }
1360 status = (headlessif->iff_peer != NULL)
1361 ? (IFM_AVALID | IFM_ACTIVE) : IFM_AVALID;
1362 ifmr = (struct ifmediareq *)data;
1363 user_addr = (cmd == SIOCGIFMEDIA64) ?
1364 CAST_USER_ADDR_T(((struct ifmediareq64 *)ifmr)->ifmu_ulist) :
1365 CAST_USER_ADDR_T(((struct ifmediareq32 *)ifmr)->ifmu_ulist);
1366 count = ifmr->ifm_count;
1367 ifmr->ifm_active = IFM_ETHER;
1368 ifmr->ifm_current = IFM_ETHER;
1369 ifmr->ifm_mask = 0;
1370 ifmr->ifm_status = status;
1371 if (user_addr == USER_ADDR_NULL) {
1372 ifmr->ifm_count = headlessif->iff_media_count;
1373 } else if (count > 0) {
1374 if (count > headlessif->iff_media_count) {
1375 count = headlessif->iff_media_count;
1376 }
1377 ifmr->ifm_count = count;
1378 error = copyout(&headlessif->iff_media_list, user_addr,
1379 count * sizeof(int));
1380 }
1381 headless_unlock();
1382 break;
1383
1384 case SIOCGIFDEVMTU:
1385 devmtu_p = &ifr->ifr_devmtu;
1386 devmtu_p->ifdm_current = ifnet_mtu(ifp);
1387 devmtu_p->ifdm_max = headless_max_mtu(ifp);
1388 devmtu_p->ifdm_min = IF_MINMTU;
1389 break;
1390
1391 case SIOCSIFMTU:
1392 if ((unsigned int)ifr->ifr_mtu > headless_max_mtu(ifp) ||
1393 ifr->ifr_mtu < IF_MINMTU) {
1394 error = EINVAL;
1395 } else {
1396 error = ifnet_set_mtu(ifp, ifr->ifr_mtu);
1397 }
1398 break;
1399
1400 case SIOCSDRVSPEC32:
1401 case SIOCSDRVSPEC64:
1402 error = proc_suser(current_proc());
1403 if (error != 0) {
1404 break;
1405 }
1406 drv_set_command = TRUE;
1407 OS_FALLTHROUGH;
1408 case SIOCGDRVSPEC32:
1409 case SIOCGDRVSPEC64:
1410 drv.ifdrvu_p = data;
1411 if (cmd == SIOCGDRVSPEC32 || cmd == SIOCSDRVSPEC32) {
1412 drv_cmd = drv.ifdrvu_32->ifd_cmd;
1413 drv_len = drv.ifdrvu_32->ifd_len;
1414 user_addr = CAST_USER_ADDR_T(drv.ifdrvu_32->ifd_data);
1415 } else {
1416 drv_cmd = drv.ifdrvu_64->ifd_cmd;
1417 drv_len = drv.ifdrvu_64->ifd_len;
1418 user_addr = CAST_USER_ADDR_T(drv.ifdrvu_64->ifd_data);
1419 }
1420 if (drv_set_command) {
1421 error = headless_set_drvspec(ifp, drv_cmd,
1422 (size_t)drv_len, user_addr);
1423 } else {
1424 error = headless_get_drvspec(ifp, drv_cmd,
1425 (size_t)drv_len, user_addr);
1426 }
1427 break;
1428
1429 case SIOCSIFLLADDR:
1430 error = ifnet_set_lladdr(ifp, ifr->ifr_addr.sa_data,
1431 ifr->ifr_addr.sa_len);
1432 break;
1433
1434 case SIOCSIFFLAGS:
1435 if ((ifp->if_flags & IFF_UP) != 0) {
1436 /* marked up, set running if not already set */
1437 if ((ifp->if_flags & IFF_RUNNING) == 0) {
1438 /* set running */
1439 error = ifnet_set_flags(ifp, IFF_RUNNING,
1440 IFF_RUNNING);
1441 }
1442 } else if ((ifp->if_flags & IFF_RUNNING) != 0) {
1443 /* marked down, clear running */
1444 error = ifnet_set_flags(ifp, 0, IFF_RUNNING);
1445 }
1446 break;
1447
1448 case SIOCADDMULTI:
1449 case SIOCDELMULTI:
1450 error = 0;
1451 break;
1452 default:
1453 error = EOPNOTSUPP;
1454 break;
1455 }
1456 return error;
1457 }
1458
1459 static void
headless_if_free(ifnet_t ifp)1460 headless_if_free(ifnet_t ifp)
1461 {
1462 if_headless_ref headlessif;
1463
1464 if (ifp == NULL) {
1465 return;
1466 }
1467 headless_lock();
1468 headlessif = ifnet_get_if_headless(ifp);
1469 if (headlessif == NULL) {
1470 headless_unlock();
1471 return;
1472 }
1473 ifp->if_softc = NULL;
1474 assert(headlessif->iff_doorbell_tcall == NULL);
1475 headless_unlock();
1476 headless_release(headlessif);
1477 ifnet_release(ifp);
1478 return;
1479 }
1480
1481 void
if_headless_init(void)1482 if_headless_init(void)
1483 {
1484 int error;
1485
1486 (void)headless_register_nexus_domain_provider();
1487 error = if_clone_attach(&headless_zero_cloner);
1488 if (error != 0) {
1489 return;
1490 }
1491 error = if_clone_attach(&headless_null_cloner);
1492 if (error != 0) {
1493 if_clone_detach(&headless_zero_cloner);
1494 return;
1495 }
1496 return;
1497 }
1498 #else /* !SKYWALK */
1499 extern void if_headless_init(void);
1500
1501 void
if_headless_init(void)1502 if_headless_init(void)
1503 {
1504 /* nothing here */
1505 }
1506 #endif /* SKYWALK */
1507