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 * __single 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 __single;
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 nexus_domain_provider_name_t headless_provider_name = "com.apple.headless";
513
514 /* headless_nxdp_init() is called before this function returns */
515 err = kern_nexus_register_domain_provider(NEXUS_TYPE_NET_IF,
516 headless_provider_name,
517 &dp_init, sizeof(dp_init),
518 &headless_nx_dom_prov);
519 if (err != 0) {
520 printf("%s: failed to register domain provider\n", __func__);
521 return err;
522 }
523 return 0;
524 }
525
526 /**
527 ** netif nexus routines
528 **/
529 static if_headless_ref
headless_nexus_context(kern_nexus_t nexus)530 headless_nexus_context(kern_nexus_t nexus)
531 {
532 if_headless_ref headlessif;
533
534 headlessif = (if_headless_ref)kern_nexus_get_context(nexus);
535 assert(headlessif != NULL);
536 return headlessif;
537 }
538
539 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)540 headless_nx_ring_init(kern_nexus_provider_t nxprov, kern_nexus_t nexus,
541 kern_channel_t channel, kern_channel_ring_t ring, boolean_t is_tx_ring,
542 void **ring_ctx)
543 {
544 if_headless_ref headlessif;
545 #pragma unused(nxprov, channel, ring_ctx)
546 headless_lock();
547 headlessif = headless_nexus_context(nexus);
548 if (headless_is_detaching(headlessif)) {
549 headless_unlock();
550 return 0;
551 }
552 if (is_tx_ring) {
553 assert(headlessif->iff_tx_ring[0] == NULL);
554 headlessif->iff_tx_ring[0] = ring;
555 } else {
556 assert(headlessif->iff_rx_ring[0] == NULL);
557 headlessif->iff_rx_ring[0] = ring;
558 }
559 headless_unlock();
560 HEADLESS_DPRINTF("%s: %s ring init\n",
561 headlessif->iff_name, is_tx_ring ? "TX" : "RX");
562 return 0;
563 }
564
565 static void
headless_nx_ring_fini(kern_nexus_provider_t nxprov,kern_nexus_t nexus,kern_channel_ring_t ring)566 headless_nx_ring_fini(kern_nexus_provider_t nxprov, kern_nexus_t nexus,
567 kern_channel_ring_t ring)
568 {
569 #pragma unused(nxprov, ring)
570 if_headless_ref headlessif;
571 thread_call_t tcall __single = NULL;
572
573 headless_lock();
574 headlessif = headless_nexus_context(nexus);
575 if (headlessif->iff_rx_ring[0] == ring) {
576 headlessif->iff_rx_ring[0] = NULL;
577 HEADLESS_DPRINTF("%s: RX ring fini\n", headlessif->iff_name);
578 } else if (headlessif->iff_tx_ring[0] == ring) {
579 tcall = headlessif->iff_doorbell_tcall;
580 headlessif->iff_doorbell_tcall = NULL;
581 headlessif->iff_tx_ring[0] = NULL;
582 }
583 headless_unlock();
584 if (tcall != NULL) {
585 boolean_t success;
586
587 success = thread_call_cancel_wait(tcall);
588 HEADLESS_DPRINTF("%s: thread_call_cancel %s\n",
589 headlessif->iff_name,
590 success ? "SUCCESS" : "FAILURE");
591 if (!success) {
592 headless_lock();
593 if (headlessif->iff_tcall_active) {
594 headlessif->iff_waiting_for_tcall = TRUE;
595 HEADLESS_DPRINTF("%s: *waiting for threadcall\n",
596 headlessif->iff_name);
597 do {
598 msleep(headlessif, &headless_lck_mtx,
599 PZERO, "headless threadcall", 0);
600 } while (headlessif->iff_tcall_active);
601 HEADLESS_DPRINTF("%s: ^threadcall done\n",
602 headlessif->iff_name);
603 headlessif->iff_waiting_for_tcall = FALSE;
604 }
605 headless_unlock();
606 }
607 success = thread_call_free(tcall);
608 HEADLESS_DPRINTF("%s: thread_call_free %s\n",
609 headlessif->iff_name,
610 success ? "SUCCESS" : "FAILURE");
611 headless_release(headlessif);
612 assert(success == TRUE);
613 }
614 }
615
616 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)617 headless_nx_pre_connect(kern_nexus_provider_t nxprov,
618 proc_t proc, kern_nexus_t nexus, nexus_port_t port, kern_channel_t channel,
619 void **channel_context)
620 {
621 #pragma unused(nxprov, proc, nexus, port, channel, channel_context)
622 return 0;
623 }
624
625 static errno_t
headless_nx_connected(kern_nexus_provider_t nxprov,kern_nexus_t nexus,kern_channel_t channel)626 headless_nx_connected(kern_nexus_provider_t nxprov,
627 kern_nexus_t nexus, kern_channel_t channel)
628 {
629 #pragma unused(nxprov, channel)
630 if_headless_ref headlessif;
631
632 headlessif = headless_nexus_context(nexus);
633 headless_lock();
634 if (headless_is_detaching(headlessif)) {
635 headless_unlock();
636 return EBUSY;
637 }
638 headless_retain(headlessif);
639 headlessif->iff_channel_connected = TRUE;
640 headless_unlock();
641 HEADLESS_DPRINTF("%s: connected channel %p\n",
642 headlessif->iff_name, channel);
643 return 0;
644 }
645
646 static void
headless_nx_pre_disconnect(kern_nexus_provider_t nxprov,kern_nexus_t nexus,kern_channel_t channel)647 headless_nx_pre_disconnect(kern_nexus_provider_t nxprov,
648 kern_nexus_t nexus, kern_channel_t channel)
649 {
650 #pragma unused(nxprov, channel)
651 if_headless_ref headlessif;
652
653 headlessif = headless_nexus_context(nexus);
654 HEADLESS_DPRINTF("%s: pre-disconnect channel %p\n",
655 headlessif->iff_name, channel);
656 /* Quiesce the interface and flush any pending outbound packets. */
657 if_down(headlessif->iff_ifp);
658 headless_lock();
659 headlessif->iff_channel_connected = FALSE;
660 headless_unlock();
661 }
662
663 static void
headless_nx_disconnected(kern_nexus_provider_t nxprov,kern_nexus_t nexus,kern_channel_t channel)664 headless_nx_disconnected(kern_nexus_provider_t nxprov,
665 kern_nexus_t nexus, kern_channel_t channel)
666 {
667 #pragma unused(nxprov, channel)
668 if_headless_ref headlessif;
669
670 headlessif = headless_nexus_context(nexus);
671 HEADLESS_DPRINTF("%s: disconnected channel %p\n",
672 headlessif->iff_name, channel);
673 headless_release(headlessif);
674 }
675
676 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)677 headless_nx_slot_init(kern_nexus_provider_t nxprov,
678 kern_nexus_t nexus, kern_channel_ring_t ring, kern_channel_slot_t slot,
679 uint32_t slot_index, struct kern_slot_prop **slot_prop_addr,
680 void **slot_context)
681 {
682 #pragma unused(nxprov, nexus, ring, slot, slot_index, slot_prop_addr, slot_context)
683 return 0;
684 }
685
686 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)687 headless_nx_slot_fini(kern_nexus_provider_t nxprov,
688 kern_nexus_t nexus, kern_channel_ring_t ring, kern_channel_slot_t slot,
689 uint32_t slot_index)
690 {
691 #pragma unused(nxprov, nexus, ring, slot, slot_index)
692 }
693
694 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)695 headless_nx_sync_tx(kern_nexus_provider_t nxprov,
696 kern_nexus_t nexus, kern_channel_ring_t tx_ring, uint32_t flags)
697 {
698 #pragma unused(nxprov)
699 if_headless_ref headlessif;
700 ifnet_t ifp;
701 kern_channel_slot_t last_tx_slot = NULL;
702 struct kern_channel_ring_stat_increment stats = {
703 .kcrsi_slots_transferred = 0, .kcrsi_bytes_transferred = 0
704 };
705 kern_channel_slot_t tx_slot;
706 struct netif_stats *nifs = &NX_NETIF_PRIVATE(nexus)->nif_stats;
707
708 STATS_INC(nifs, NETIF_STATS_TX_SYNC);
709 headlessif = headless_nexus_context(nexus);
710 HEADLESS_DPRINTF("%s ring %d flags 0x%x\n", headlessif->iff_name,
711 tx_ring->ckr_ring_id, flags);
712
713 headless_lock();
714 if (headless_is_detaching(headlessif) ||
715 !headlessif->iff_channel_connected) {
716 headless_unlock();
717 return 0;
718 }
719 headless_unlock();
720 ifp = headlessif->iff_ifp;
721 tx_slot = kern_channel_get_next_slot(tx_ring, NULL, NULL);
722 while (tx_slot != NULL) {
723 kern_packet_t ph;
724
725 /* detach the packet from the TX ring */
726 ph = kern_channel_slot_get_packet(tx_ring, tx_slot);
727 assert(ph != 0);
728 kern_channel_slot_detach_packet(tx_ring, tx_slot, ph);
729
730 kern_pbufpool_free(headlessif->iff_fpp->fpp_pp, ph);
731 last_tx_slot = tx_slot;
732 tx_slot = kern_channel_get_next_slot(tx_ring, tx_slot, NULL);
733 STATS_INC(nifs, NETIF_STATS_TX_PACKETS);
734 }
735
736 if (last_tx_slot != NULL) {
737 kern_channel_advance_slot(tx_ring, last_tx_slot);
738 kern_channel_increment_ring_net_stats(tx_ring, ifp, &stats);
739 }
740 return 0;
741 }
742
743 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)744 headless_nx_sync_rx_null(kern_nexus_provider_t nxprov,
745 kern_nexus_t nexus, kern_channel_ring_t rx_ring, uint32_t flags)
746 {
747 #pragma unused(nxprov, rx_ring, flags)
748 if_headless_ref headlessif;
749 struct netif_stats *nifs = &NX_NETIF_PRIVATE(nexus)->nif_stats;
750
751 headlessif = headless_nexus_context(nexus);
752 HEADLESS_DPRINTF("%s:\n", headlessif->iff_name);
753 STATS_INC(nifs, NETIF_STATS_RX_SYNC);
754 return 0;
755 }
756
757 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)758 headless_nx_sync_rx(kern_nexus_provider_t nxprov,
759 kern_nexus_t nexus, kern_channel_ring_t rx_ring, uint32_t flags)
760 {
761 #pragma unused(nxprov)
762 if_headless_ref headlessif;
763 ifnet_t ifp;
764 kern_channel_slot_t last_rx_slot = NULL;
765 struct kern_channel_ring_stat_increment stats = {
766 .kcrsi_slots_transferred = 0, .kcrsi_bytes_transferred = 0
767 };
768 kern_channel_slot_t rx_slot;
769 struct netif_stats *nifs = &NX_NETIF_PRIVATE(nexus)->nif_stats;
770
771 kern_channel_reclaim(rx_ring);
772 STATS_INC(nifs, NETIF_STATS_RX_SYNC);
773 headlessif = headless_nexus_context(nexus);
774 HEADLESS_DPRINTF("%s ring %d flags 0x%x\n", headlessif->iff_name,
775 rx_ring->ckr_ring_id, flags);
776
777 headless_lock();
778 if (headless_is_detaching(headlessif) ||
779 !headlessif->iff_channel_connected) {
780 headless_unlock();
781 return 0;
782 }
783 headless_unlock();
784 ifp = headlessif->iff_ifp;
785 rx_slot = kern_channel_get_next_slot(rx_ring, NULL, NULL);
786 kern_pbufpool_t pp = headlessif->iff_fpp->fpp_pp;
787 while (rx_slot != NULL) {
788 kern_packet_t ph;
789 kern_buflet_t buf = NULL;
790 int err;
791 err = kern_pbufpool_alloc(pp, 1, &ph);
792 buf = kern_packet_get_next_buflet(ph, buf);
793 kern_buflet_set_data_offset(buf, 0);
794 if (if_headless_create_payload) {
795 // This is a plain TCP SYN packet
796 uint64_t * addr = __unsafe_forge_bidi_indexable(uint64_t *,
797 kern_buflet_get_data_address(buf),
798 kern_buflet_get_data_limit(buf));
799 uint64_t *u64 = addr;
800 *(u64 + 0) = 0xc100d51dc3355b68ULL;
801 *(u64 + 1) = 0x004500084019c564ULL;
802 *(u64 + 2) = 0x0634004000004000ULL;
803 *(u64 + 3) = 0x716111e3068d11c0ULL;
804 *(u64 + 4) = 0xc0118d06e3116171ULL;
805 *(u64 + 5) = 0x8a3700000000b002ULL;
806 *(u64 + 6) = 0x02b000000000378aULL;
807 *(u64 + 7) = 0x010106030301b405ULL;
808 *(u64 + 8) = 0x000022cc5c940a08ULL;
809 *(u64 + 9) = 0x0000040200000000ULL;
810 }
811 kern_buflet_set_data_length(buf, (uint16_t)if_headless_packet_length);
812 err = kern_packet_set_headroom(ph, 0);
813 ASSERT(err == 0);
814 err = kern_packet_set_link_header_length(ph, 14);
815 ASSERT(err == 0);
816 kern_packet_finalize(ph);
817
818 kern_channel_slot_attach_packet(rx_ring, rx_slot, ph);
819
820 STATS_INC(nifs, NETIF_STATS_RX_PACKETS);
821 last_rx_slot = rx_slot;
822 rx_slot = kern_channel_get_next_slot(rx_ring, rx_slot, NULL);
823 }
824
825 if (last_rx_slot != NULL) {
826 kern_channel_advance_slot(rx_ring, last_rx_slot);
827 kern_channel_increment_ring_net_stats(rx_ring, ifp, &stats);
828 }
829 return 0;
830 }
831
832 static void
headless_async_doorbell(thread_call_param_t arg0,thread_call_param_t arg1)833 headless_async_doorbell(thread_call_param_t arg0, thread_call_param_t arg1)
834 {
835 #pragma unused(arg1)
836 errno_t error;
837 if_headless_ref headlessif = (if_headless_ref)arg0;
838 kern_channel_ring_t ring;
839 boolean_t more;
840
841 headless_lock();
842 ring = headlessif->iff_tx_ring[0];
843 if (headless_is_detaching(headlessif) ||
844 !headlessif->iff_channel_connected ||
845 ring == NULL) {
846 goto done;
847 }
848 headlessif->iff_tcall_active = TRUE;
849 headless_unlock();
850 error = kern_channel_tx_refill(ring, UINT32_MAX,
851 UINT32_MAX, FALSE, &more);
852 if (error != 0) {
853 HEADLESS_DPRINTF("%s: TX refill failed %d\n",
854 headlessif->iff_name, error);
855 } else {
856 HEADLESS_DPRINTF("%s: TX refilled\n", headlessif->iff_name);
857 }
858
859 headless_lock();
860 done:
861 headlessif->iff_tcall_active = FALSE;
862 if (headlessif->iff_waiting_for_tcall) {
863 HEADLESS_DPRINTF("%s: threadcall waking up waiter\n",
864 headlessif->iff_name);
865 wakeup((caddr_t)headlessif);
866 }
867 headless_unlock();
868 }
869
870 static void
headless_schedule_async_doorbell(if_headless_ref headlessif)871 headless_schedule_async_doorbell(if_headless_ref headlessif)
872 {
873 thread_call_t __single tcall;
874
875 headless_lock();
876 if (headless_is_detaching(headlessif) ||
877 !headlessif->iff_channel_connected) {
878 headless_unlock();
879 return;
880 }
881 tcall = headlessif->iff_doorbell_tcall;
882 if (tcall != NULL) {
883 thread_call_enter(tcall);
884 } else {
885 tcall = thread_call_allocate_with_options(headless_async_doorbell,
886 (thread_call_param_t)headlessif,
887 THREAD_CALL_PRIORITY_KERNEL,
888 THREAD_CALL_OPTIONS_ONCE);
889 if (tcall == NULL) {
890 printf("%s: %s tcall alloc failed\n",
891 __func__, headlessif->iff_name);
892 } else {
893 headlessif->iff_doorbell_tcall = tcall;
894 headless_retain(headlessif);
895 thread_call_enter(tcall);
896 }
897 }
898 headless_unlock();
899 }
900
901 static errno_t
headless_nx_tx_doorbell(kern_nexus_provider_t nxprov,kern_nexus_t nexus,kern_channel_ring_t ring,uint32_t flags)902 headless_nx_tx_doorbell(kern_nexus_provider_t nxprov,
903 kern_nexus_t nexus, kern_channel_ring_t ring, uint32_t flags)
904 {
905 #pragma unused(nxprov, ring, flags)
906 errno_t error;
907 if_headless_ref headlessif;
908
909 headlessif = headless_nexus_context(nexus);
910 HEADLESS_DPRINTF("%s\n", headlessif->iff_name);
911
912 if ((flags & KERN_NEXUS_TXDOORBELLF_ASYNC_REFILL) == 0) {
913 boolean_t more;
914 /* synchronous tx refill */
915 error = kern_channel_tx_refill(ring, UINT32_MAX,
916 UINT32_MAX, TRUE, &more);
917 if (error != 0) {
918 HEADLESS_DPRINTF("%s: TX refill (sync) %d\n",
919 headlessif->iff_name, error);
920 } else {
921 HEADLESS_DPRINTF("%s: TX refilled (sync)\n",
922 headlessif->iff_name);
923 }
924 } else {
925 HEADLESS_DPRINTF("%s: schedule async refill\n",
926 headlessif->iff_name);
927 headless_schedule_async_doorbell(headlessif);
928 }
929 return 0;
930 }
931
932 static errno_t
headless_netif_prepare(kern_nexus_t nexus,ifnet_t ifp)933 headless_netif_prepare(kern_nexus_t nexus, ifnet_t ifp)
934 {
935 if_headless_ref headlessif;
936
937 headlessif = (if_headless_ref)kern_nexus_get_context(nexus);
938 headless_ifnet_set_attrs(headlessif, ifp);
939 return 0;
940 }
941
942 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)943 create_netif_provider_and_instance(if_headless_ref headlessif,
944 struct ifnet_init_eparams * init_params, ifnet_t *ifp,
945 uuid_t * provider, uuid_t * instance)
946 {
947 errno_t err;
948 nexus_controller_t controller = kern_nexus_shared_controller();
949 struct kern_nexus_net_init net_init;
950 nexus_name_t provider_name;
951 nexus_attr_t nexus_attr = NULL;
952 struct kern_nexus_provider_init prov_init = {
953 .nxpi_version = KERN_NEXUS_DOMAIN_PROVIDER_CURRENT_VERSION,
954 .nxpi_flags = NXPIF_VIRTUAL_DEVICE,
955 .nxpi_pre_connect = headless_nx_pre_connect,
956 .nxpi_connected = headless_nx_connected,
957 .nxpi_pre_disconnect = headless_nx_pre_disconnect,
958 .nxpi_disconnected = headless_nx_disconnected,
959 .nxpi_ring_init = headless_nx_ring_init,
960 .nxpi_ring_fini = headless_nx_ring_fini,
961 .nxpi_slot_init = headless_nx_slot_init,
962 .nxpi_slot_fini = headless_nx_slot_fini,
963 .nxpi_sync_tx = headless_nx_sync_tx,
964 .nxpi_sync_rx = headless_nx_sync_rx,
965 .nxpi_tx_doorbell = headless_nx_tx_doorbell,
966 };
967
968 if (headlessif->iff_cloner == &headless_zero_cloner) {
969 prov_init.nxpi_sync_rx = headless_nx_sync_rx;
970 prov_init.nxpi_sync_tx = headless_nx_sync_tx;
971 } else if (headlessif->iff_cloner == &headless_null_cloner) {
972 prov_init.nxpi_sync_rx = headless_nx_sync_rx_null;
973 prov_init.nxpi_sync_tx = headless_nx_sync_tx;
974 }
975
976 _CASSERT(IFF_MAX_RX_RINGS == 1);
977
978 snprintf((char *)provider_name, sizeof(provider_name),
979 "com.apple.netif.%s", headlessif->iff_name);
980 err = kern_nexus_controller_register_provider(controller,
981 headless_nx_dom_prov,
982 provider_name,
983 &prov_init,
984 sizeof(prov_init),
985 nexus_attr,
986 provider);
987 if (err != 0) {
988 printf("%s register provider failed, error %d\n",
989 __func__, err);
990 goto failed;
991 }
992 bzero(&net_init, sizeof(net_init));
993 net_init.nxneti_version = KERN_NEXUS_NET_CURRENT_VERSION;
994 net_init.nxneti_flags = 0;
995 net_init.nxneti_eparams = init_params;
996 net_init.nxneti_lladdr = NULL;
997 net_init.nxneti_prepare = headless_netif_prepare;
998 net_init.nxneti_rx_pbufpool = headlessif->iff_fpp->fpp_pp;
999 net_init.nxneti_tx_pbufpool = headlessif->iff_fpp->fpp_pp;
1000 err = kern_nexus_controller_alloc_net_provider_instance(controller,
1001 *provider,
1002 headlessif,
1003 NULL,
1004 instance,
1005 &net_init,
1006 ifp);
1007 if (err != 0) {
1008 printf("%s alloc_net_provider_instance failed, %d\n",
1009 __func__, err);
1010 kern_nexus_controller_deregister_provider(controller,
1011 *provider);
1012 uuid_clear(*provider);
1013 goto failed;
1014 }
1015
1016 failed:
1017 if (nexus_attr != NULL) {
1018 kern_nexus_attr_destroy(nexus_attr);
1019 }
1020 return err;
1021 }
1022
1023
1024 static errno_t
headless_attach_netif_nexus(if_headless_ref headlessif,struct ifnet_init_eparams * init_params,ifnet_t * ifp)1025 headless_attach_netif_nexus(if_headless_ref headlessif,
1026 struct ifnet_init_eparams * init_params, ifnet_t *ifp)
1027 {
1028 headless_packet_pool_t fpp;
1029 headless_nx_t nx = &headlessif->iff_nx;
1030 boolean_t multi_buflet;
1031
1032 multi_buflet = headless_using_multibuflets(headlessif);
1033 fpp = headless_packet_pool_alloc(multi_buflet, headlessif->iff_max_mtu);
1034 if (fpp == NULL) {
1035 return ENOMEM;
1036 }
1037 headlessif->iff_fpp = fpp;
1038 return create_netif_provider_and_instance(headlessif, init_params, ifp,
1039 &nx->fnx_provider,
1040 &nx->fnx_instance);
1041 }
1042
1043 static void
detach_provider_and_instance(uuid_t provider,uuid_t instance)1044 detach_provider_and_instance(uuid_t provider, uuid_t instance)
1045 {
1046 nexus_controller_t controller = kern_nexus_shared_controller();
1047 errno_t err;
1048
1049 if (!uuid_is_null(instance)) {
1050 err = kern_nexus_controller_free_provider_instance(controller,
1051 instance);
1052 if (err != 0) {
1053 printf("%s free_provider_instance failed %d\n",
1054 __func__, err);
1055 }
1056 uuid_clear(instance);
1057 }
1058 if (!uuid_is_null(provider)) {
1059 err = kern_nexus_controller_deregister_provider(controller,
1060 provider);
1061 if (err != 0) {
1062 printf("%s deregister_provider %d\n", __func__, err);
1063 }
1064 uuid_clear(provider);
1065 }
1066 return;
1067 }
1068
1069 static void
headless_detach_netif_nexus(headless_nx_t nx)1070 headless_detach_netif_nexus(headless_nx_t nx)
1071 {
1072 detach_provider_and_instance(nx->fnx_provider, nx->fnx_instance);
1073 }
1074
1075 /**
1076 ** headless interface routines
1077 **/
1078 static void
headless_ifnet_set_attrs(if_headless_ref headlessif,ifnet_t ifp)1079 headless_ifnet_set_attrs(if_headless_ref headlessif, ifnet_t ifp)
1080 {
1081 (void)ifnet_set_capabilities_enabled(ifp, 0, -1);
1082 ifnet_set_addrlen(ifp, ETHER_ADDR_LEN);
1083 ifnet_set_baudrate(ifp, 0);
1084 ifnet_set_mtu(ifp, ETHERMTU);
1085 ifnet_set_flags(ifp,
1086 IFF_BROADCAST | IFF_MULTICAST | IFF_SIMPLEX,
1087 0xffff);
1088 ifnet_set_hdrlen(ifp, sizeof(struct ether_header));
1089 if ((headlessif->iff_flags & IFF_FLAGS_HWCSUM) != 0) {
1090 ifnet_set_offload(ifp,
1091 IFNET_CSUM_IP | IFNET_CSUM_TCP | IFNET_CSUM_UDP |
1092 IFNET_CSUM_TCPIPV6 | IFNET_CSUM_UDPIPV6);
1093 } else {
1094 ifnet_set_offload(ifp, 0);
1095 }
1096 }
1097
1098 static void
interface_link_event(ifnet_t ifp,u_int32_t event_code)1099 interface_link_event(ifnet_t ifp, u_int32_t event_code)
1100 {
1101 struct event {
1102 u_int32_t ifnet_family;
1103 u_int32_t unit;
1104 char if_name[IFNAMSIZ];
1105 };
1106 _Alignas(struct kern_event_msg) char message[sizeof(struct kern_event_msg) + sizeof(struct event)] = { 0 };
1107 struct kern_event_msg *header = (struct kern_event_msg*)message;
1108 struct event *data = (struct event *)(message + KEV_MSG_HEADER_SIZE);
1109
1110 header->total_size = sizeof(message);
1111 header->vendor_code = KEV_VENDOR_APPLE;
1112 header->kev_class = KEV_NETWORK_CLASS;
1113 header->kev_subclass = KEV_DL_SUBCLASS;
1114 header->event_code = event_code;
1115 data->ifnet_family = ifnet_family(ifp);
1116 data->unit = (u_int32_t)ifnet_unit(ifp);
1117 strlcpy(data->if_name, ifnet_name(ifp), IFNAMSIZ);
1118 ifnet_event(ifp, header);
1119 }
1120
1121 static if_headless_ref
ifnet_get_if_headless(ifnet_t ifp)1122 ifnet_get_if_headless(ifnet_t ifp)
1123 {
1124 return (if_headless_ref)ifnet_softc(ifp);
1125 }
1126
1127 static int
headless_clone_create(struct if_clone * ifc,u_int32_t unit,void * params)1128 headless_clone_create(struct if_clone *ifc, u_int32_t unit, void *params)
1129 {
1130 #pragma unused(params)
1131 int error;
1132 if_headless_ref headlessif;
1133 struct ifnet_init_eparams headless_init;
1134 ifnet_ref_t ifp;
1135 uint8_t mac_address[ETHER_ADDR_LEN];
1136
1137 headlessif = kalloc_type(struct if_headless, Z_WAITOK_ZERO_NOFAIL);
1138 headlessif->iff_retain_count = 1;
1139 if (strbufcmp(ifc->ifc_name, HEADLESS_ZERO_IFNAME) == 0) {
1140 headlessif->iff_cloner = &headless_zero_cloner;
1141 ASSERT(strlen(HEADLESS_ZERO_IFNAME) == 4);
1142 bcopy(HEADLESS_ZERO_IFNAME, mac_address, 4);
1143 } else {
1144 headlessif->iff_cloner = &headless_null_cloner;
1145 ASSERT(strlen(HEADLESS_NULL_IFNAME) == 4);
1146 bcopy(HEADLESS_NULL_IFNAME, mac_address, 4);
1147 }
1148 mac_address[ETHER_ADDR_LEN - 2] = (unit & 0xff00) >> 8;
1149 mac_address[ETHER_ADDR_LEN - 1] = unit & 0xff;
1150 headlessif->iff_max_mtu = if_headless_max_mtu;
1151
1152 /* use the interface name as the unique id for ifp recycle */
1153 if ((unsigned int)
1154 snprintf(headlessif->iff_name, sizeof(headlessif->iff_name), "%s%d",
1155 ifc->ifc_name, unit) >= sizeof(headlessif->iff_name)) {
1156 headless_release(headlessif);
1157 return EINVAL;
1158 }
1159 bzero(&headless_init, sizeof(headless_init));
1160 headless_init.ver = IFNET_INIT_CURRENT_VERSION;
1161 headless_init.len = sizeof(headless_init);
1162 headless_init.flags |= IFNET_INIT_SKYWALK_NATIVE;
1163 if (if_headless_multibuflet != 0) {
1164 headlessif->iff_flags |= IFF_FLAGS_MULTIBUFLETS;
1165 }
1166
1167 headlessif->iff_tx_headroom = if_headless_tx_headroom;
1168 headless_init.tx_headroom = headlessif->iff_tx_headroom;
1169 if (if_headless_nxattach == 0) {
1170 headless_init.flags |= IFNET_INIT_NX_NOAUTO;
1171 }
1172 headless_init.uniqueid_len = (uint32_t)strbuflen(headlessif->iff_name);
1173 headless_init.uniqueid = headlessif->iff_name;
1174 headless_init.name = __unsafe_null_terminated_from_indexable(ifc->ifc_name);
1175 headless_init.unit = unit;
1176 headless_init.family = IFNET_FAMILY_ETHERNET;
1177 headless_init.type = IFT_ETHER;
1178 headless_init.demux = ether_demux;
1179 headless_init.add_proto = ether_add_proto;
1180 headless_init.del_proto = ether_del_proto;
1181 headless_init.check_multi = ether_check_multi;
1182 headless_init.framer_extended = ether_frameout_extended;
1183 headless_init.softc = headlessif;
1184 headless_init.ioctl = headless_ioctl;
1185 headless_init.set_bpf_tap = NULL;
1186 headless_init.detach = headless_if_free;
1187 headless_init.broadcast_addr = etherbroadcastaddr;
1188 headless_init.broadcast_len = ETHER_ADDR_LEN;
1189 error = headless_attach_netif_nexus(headlessif, &headless_init, &ifp);
1190 if (error != 0) {
1191 headless_release(headlessif);
1192 return error;
1193 }
1194 /* take an additional reference to ensure that it doesn't go away */
1195 headless_retain(headlessif);
1196 headlessif->iff_ifp = ifp;
1197 headlessif->iff_media_count = default_media_words_count;
1198 bcopy(default_media_words, headlessif->iff_media_list,
1199 sizeof(default_media_words));
1200 ifnet_set_lladdr(ifp, mac_address, sizeof(mac_address));
1201
1202 /* attach as ethernet */
1203 bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header));
1204
1205 interface_link_event(ifp, KEV_DL_LINK_ON);
1206
1207 return 0;
1208 }
1209
1210 static int
headless_clone_destroy(ifnet_t ifp)1211 headless_clone_destroy(ifnet_t ifp)
1212 {
1213 if_headless_ref headlessif;
1214 headless_nx nx;
1215 boolean_t nx_attached = FALSE;
1216
1217 interface_link_event(ifp, KEV_DL_LINK_OFF);
1218 headless_lock();
1219 headlessif = ifnet_get_if_headless(ifp);
1220 if (headlessif == NULL || headless_is_detaching(headlessif)) {
1221 headless_unlock();
1222 return 0;
1223 }
1224 headless_set_detaching(headlessif);
1225 nx_attached = TRUE;
1226 nx = headlessif->iff_nx;
1227 bzero(&headlessif->iff_nx, sizeof(headlessif->iff_nx));
1228 headless_unlock();
1229
1230 if (nx_attached) {
1231 headless_detach_netif_nexus(&nx);
1232 headless_release(headlessif);
1233 }
1234 ifnet_detach(ifp);
1235 return 0;
1236 }
1237
1238 static int
headless_set_media(ifnet_t ifp,struct if_headless_request * iffr)1239 headless_set_media(ifnet_t ifp, struct if_headless_request * iffr)
1240 {
1241 if_headless_ref headlessif;
1242 int error;
1243
1244 if (iffr->iffr_media.iffm_count > IF_HEADLESS_MEDIA_LIST_MAX) {
1245 /* list is too long */
1246 return EINVAL;
1247 }
1248 headless_lock();
1249 headlessif = ifnet_get_if_headless(ifp);
1250 if (headlessif == NULL) {
1251 error = EINVAL;
1252 goto done;
1253 }
1254 headlessif->iff_media_count = iffr->iffr_media.iffm_count;
1255 bcopy(iffr->iffr_media.iffm_list, headlessif->iff_media_list,
1256 iffr->iffr_media.iffm_count * sizeof(headlessif->iff_media_list[0]));
1257 #if 0
1258 /* XXX: "auto-negotiate" active with peer? */
1259 /* generate link status event? */
1260 headlessif->iff_media_current = iffr->iffr_media.iffm_current;
1261 #endif
1262 error = 0;
1263 done:
1264 headless_unlock();
1265 return error;
1266 }
1267
1268 static int
if_headless_request_copyin(user_addr_t user_addr,struct if_headless_request * iffr,size_t len)1269 if_headless_request_copyin(user_addr_t user_addr,
1270 struct if_headless_request *iffr, size_t len)
1271 {
1272 int error;
1273
1274 if (user_addr == USER_ADDR_NULL || len < sizeof(*iffr)) {
1275 error = EINVAL;
1276 goto done;
1277 }
1278 error = copyin(user_addr, iffr, sizeof(*iffr));
1279 if (error != 0) {
1280 goto done;
1281 }
1282 if (iffr->iffr_reserved[0] != 0 || iffr->iffr_reserved[1] != 0 ||
1283 iffr->iffr_reserved[2] != 0 || iffr->iffr_reserved[3] != 0) {
1284 error = EINVAL;
1285 goto done;
1286 }
1287 done:
1288 return error;
1289 }
1290
1291 static int
headless_set_drvspec(ifnet_t ifp,uint64_t cmd,size_t len,user_addr_t user_addr)1292 headless_set_drvspec(ifnet_t ifp, uint64_t cmd, size_t len,
1293 user_addr_t user_addr)
1294 {
1295 int error;
1296 struct if_headless_request iffr;
1297
1298 switch (cmd) {
1299 case IF_HEADLESS_S_CMD_SET_MEDIA:
1300 error = if_headless_request_copyin(user_addr, &iffr, len);
1301 if (error != 0) {
1302 break;
1303 }
1304 error = headless_set_media(ifp, &iffr);
1305 break;
1306 default:
1307 error = EOPNOTSUPP;
1308 break;
1309 }
1310 return error;
1311 }
1312
1313 static int
headless_get_drvspec(ifnet_t ifp,uint64_t cmd,size_t len,user_addr_t user_addr)1314 headless_get_drvspec(ifnet_t ifp, uint64_t cmd, size_t len,
1315 user_addr_t user_addr)
1316 {
1317 #pragma unused(ifp, len, user_addr)
1318 int error = EOPNOTSUPP;
1319
1320 switch (cmd) {
1321 default:
1322 break;
1323 }
1324 return error;
1325 }
1326
1327 union ifdrvu {
1328 struct ifdrv32 *ifdrvu_32;
1329 struct ifdrv64 *ifdrvu_64;
1330 void *ifdrvu_p;
1331 };
1332
1333 static int
headless_ioctl(ifnet_t ifp,u_long cmd,void * data)1334 headless_ioctl(ifnet_t ifp, u_long cmd, void * data)
1335 {
1336 unsigned int count;
1337 struct ifdevmtu * devmtu_p;
1338 union ifdrvu drv;
1339 uint64_t drv_cmd;
1340 uint64_t drv_len;
1341 boolean_t drv_set_command = FALSE;
1342 int error = 0;
1343 struct ifmediareq32 * ifmr;
1344 struct ifreq * ifr;
1345 if_headless_ref headlessif;
1346 int status;
1347 user_addr_t user_addr;
1348
1349 ifr = (struct ifreq *)data;
1350 switch (cmd) {
1351 case SIOCSIFADDR:
1352 ifnet_set_flags(ifp, IFF_UP, IFF_UP);
1353 break;
1354
1355 case SIOCGIFMEDIA32:
1356 case SIOCGIFMEDIA64:
1357 headless_lock();
1358 headlessif = ifnet_get_if_headless(ifp);
1359 if (headlessif == NULL) {
1360 headless_unlock();
1361 return EOPNOTSUPP;
1362 }
1363 status = (headlessif->iff_peer != NULL)
1364 ? (IFM_AVALID | IFM_ACTIVE) : IFM_AVALID;
1365 ifmr = (struct ifmediareq32 *)data;
1366 user_addr = (cmd == SIOCGIFMEDIA64) ?
1367 CAST_USER_ADDR_T(((struct ifmediareq64 *)data)->ifmu_ulist) :
1368 CAST_USER_ADDR_T(((struct ifmediareq32 *)data)->ifmu_ulist);
1369 count = ifmr->ifm_count;
1370 ifmr->ifm_active = IFM_ETHER;
1371 ifmr->ifm_current = IFM_ETHER;
1372 ifmr->ifm_mask = 0;
1373 ifmr->ifm_status = status;
1374 if (user_addr == USER_ADDR_NULL) {
1375 ifmr->ifm_count = headlessif->iff_media_count;
1376 } else if (count > 0) {
1377 if (count > headlessif->iff_media_count) {
1378 count = headlessif->iff_media_count;
1379 }
1380 ifmr->ifm_count = count;
1381 error = copyout(&headlessif->iff_media_list, user_addr,
1382 count * sizeof(int));
1383 }
1384 headless_unlock();
1385 break;
1386
1387 case SIOCGIFDEVMTU:
1388 devmtu_p = &ifr->ifr_devmtu;
1389 devmtu_p->ifdm_current = ifnet_mtu(ifp);
1390 devmtu_p->ifdm_max = headless_max_mtu(ifp);
1391 devmtu_p->ifdm_min = IF_MINMTU;
1392 break;
1393
1394 case SIOCSIFMTU:
1395 if ((unsigned int)ifr->ifr_mtu > headless_max_mtu(ifp) ||
1396 ifr->ifr_mtu < IF_MINMTU) {
1397 error = EINVAL;
1398 } else {
1399 error = ifnet_set_mtu(ifp, ifr->ifr_mtu);
1400 }
1401 break;
1402
1403 case SIOCSDRVSPEC32:
1404 case SIOCSDRVSPEC64:
1405 error = proc_suser(current_proc());
1406 if (error != 0) {
1407 break;
1408 }
1409 drv_set_command = TRUE;
1410 OS_FALLTHROUGH;
1411 case SIOCGDRVSPEC32:
1412 case SIOCGDRVSPEC64:
1413 drv.ifdrvu_p = data;
1414 if (cmd == SIOCGDRVSPEC32 || cmd == SIOCSDRVSPEC32) {
1415 drv_cmd = drv.ifdrvu_32->ifd_cmd;
1416 drv_len = drv.ifdrvu_32->ifd_len;
1417 user_addr = CAST_USER_ADDR_T(drv.ifdrvu_32->ifd_data);
1418 } else {
1419 drv_cmd = drv.ifdrvu_64->ifd_cmd;
1420 drv_len = drv.ifdrvu_64->ifd_len;
1421 user_addr = CAST_USER_ADDR_T(drv.ifdrvu_64->ifd_data);
1422 }
1423 if (drv_set_command) {
1424 error = headless_set_drvspec(ifp, drv_cmd,
1425 (size_t)drv_len, user_addr);
1426 } else {
1427 error = headless_get_drvspec(ifp, drv_cmd,
1428 (size_t)drv_len, user_addr);
1429 }
1430 break;
1431
1432 case SIOCSIFLLADDR:
1433 error = ifnet_set_lladdr(ifp, ifr->ifr_addr.sa_data,
1434 ifr->ifr_addr.sa_len);
1435 break;
1436
1437 case SIOCSIFFLAGS:
1438 if ((ifp->if_flags & IFF_UP) != 0) {
1439 /* marked up, set running if not already set */
1440 if ((ifp->if_flags & IFF_RUNNING) == 0) {
1441 /* set running */
1442 error = ifnet_set_flags(ifp, IFF_RUNNING,
1443 IFF_RUNNING);
1444 }
1445 } else if ((ifp->if_flags & IFF_RUNNING) != 0) {
1446 /* marked down, clear running */
1447 error = ifnet_set_flags(ifp, 0, IFF_RUNNING);
1448 }
1449 break;
1450
1451 case SIOCADDMULTI:
1452 case SIOCDELMULTI:
1453 error = 0;
1454 break;
1455 default:
1456 error = EOPNOTSUPP;
1457 break;
1458 }
1459 return error;
1460 }
1461
1462 static void
headless_if_free(ifnet_t ifp)1463 headless_if_free(ifnet_t ifp)
1464 {
1465 if_headless_ref headlessif;
1466
1467 if (ifp == NULL) {
1468 return;
1469 }
1470 headless_lock();
1471 headlessif = ifnet_get_if_headless(ifp);
1472 if (headlessif == NULL) {
1473 headless_unlock();
1474 return;
1475 }
1476 ifp->if_softc = NULL;
1477 assert(headlessif->iff_doorbell_tcall == NULL);
1478 headless_unlock();
1479 headless_release(headlessif);
1480 ifnet_release(ifp);
1481 return;
1482 }
1483
1484 void
if_headless_init(void)1485 if_headless_init(void)
1486 {
1487 int error;
1488
1489 (void)headless_register_nexus_domain_provider();
1490 error = if_clone_attach(&headless_zero_cloner);
1491 if (error != 0) {
1492 return;
1493 }
1494 error = if_clone_attach(&headless_null_cloner);
1495 if (error != 0) {
1496 if_clone_detach(&headless_zero_cloner);
1497 return;
1498 }
1499 return;
1500 }
1501 #else /* !SKYWALK */
1502 extern void if_headless_init(void);
1503
1504 void
if_headless_init(void)1505 if_headless_init(void)
1506 {
1507 /* nothing here */
1508 }
1509 #endif /* SKYWALK */
1510