xref: /illumos-gate/usr/src/uts/common/sys/mac_impl.h (revision e5803b76927480e8f9b67b22201c484ccf4c2bcf)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23  */
24 
25 #ifndef	_SYS_MAC_IMPL_H
26 #define	_SYS_MAC_IMPL_H
27 
28 #include <sys/cpupart.h>
29 #include <sys/modhash.h>
30 #include <sys/mac_client.h>
31 #include <sys/mac_provider.h>
32 #include <sys/note.h>
33 #include <sys/avl.h>
34 #include <net/if.h>
35 #include <sys/mac_flow_impl.h>
36 #include <netinet/ip6.h>
37 
38 #ifdef	__cplusplus
39 extern "C" {
40 #endif
41 
42 /*
43  * This is the first minor number available for MAC provider private
44  * use.  This makes it possible to deliver a driver that is both a MAC
45  * provider and a regular character/block device.  See PSARC 2009/380
46  * for more detail about the construction of such devices.  The value
47  * chosen leaves half of the 32-bit minor numbers (which are really
48  * only 18 bits wide) available for driver private use.  Drivers can
49  * easily identify their private number by the presence of this value
50  * in the bits that make up the minor number, since its just the
51  * highest bit available for such minor numbers.
52  */
53 #define	MAC_PRIVATE_MINOR		((MAXMIN32 + 1) / 2)
54 
55 /*
56  * The maximum minor number that corresponds to a real instance.  This
57  * limits the number of physical ports that a mac provider can offer.
58  * Note that this macro must be synchronized with DLS_MAX_MINOR in
59  * <sys/dls.h>
60  */
61 #define	MAC_MAX_MINOR			1000
62 
63 typedef struct mac_margin_req_s	mac_margin_req_t;
64 
65 struct mac_margin_req_s {
66 	mac_margin_req_t	*mmr_nextp;
67 	uint_t			mmr_ref;
68 	uint32_t		mmr_margin;
69 };
70 
71 /* Generic linked chain type */
72 typedef	struct mac_chain_s {
73 	struct mac_chain_s	*next;
74 	void			*item;
75 } mac_chain_t;
76 
77 /*
78  * Generic mac callback list manipulation structures and macros. The mac_cb_t
79  * represents a general callback list element embedded in a particular
80  * data structure such as a mac_notify_cb_t or a mac_promisc_impl_t.
81  * The mac_cb_info_t represents general information about list walkers.
82  * Please see the comments above mac_callback_add for more information.
83  */
84 /* mcb_flags */
85 #define	MCB_CONDEMNED		0x1		/* Logically deleted */
86 #define	MCB_NOTIFY_CB_T		0x2
87 #define	MCB_TX_NOTIFY_CB_T	0x4
88 
89 extern boolean_t	mac_tx_serialize;
90 
91 typedef struct mac_cb_s {
92 	struct mac_cb_s		*mcb_nextp;	/* Linked list of callbacks */
93 	void			*mcb_objp;	/* Ptr to enclosing object  */
94 	size_t			mcb_objsize;	/* Sizeof the enclosing obj */
95 	uint_t			mcb_flags;
96 } mac_cb_t;
97 
98 typedef struct mac_cb_info_s {
99 	kmutex_t	*mcbi_lockp;
100 	kcondvar_t	mcbi_cv;
101 	uint_t		mcbi_del_cnt;		/* Deleted callback cnt */
102 	uint_t		mcbi_walker_cnt;	/* List walker count */
103 } mac_cb_info_t;
104 
105 typedef struct mac_notify_cb_s {
106 	mac_cb_t	mncb_link;		/* Linked list of callbacks */
107 	mac_notify_t	mncb_fn;		/* callback function */
108 	void		*mncb_arg;		/* callback argument */
109 	struct mac_impl_s *mncb_mip;
110 } mac_notify_cb_t;
111 
112 /*
113  * mac_callback_add(listinfo, listhead, listelement)
114  * mac_callback_remove(listinfo, listhead, listelement)
115  */
116 typedef boolean_t (*mcb_func_t)(mac_cb_info_t *, mac_cb_t **, mac_cb_t *);
117 
118 #define	MAC_CALLBACK_WALKER_INC(mcbi) {				\
119 	mutex_enter((mcbi)->mcbi_lockp);			\
120 	(mcbi)->mcbi_walker_cnt++;				\
121 	mutex_exit((mcbi)->mcbi_lockp);				\
122 }
123 
124 #define	MAC_CALLBACK_WALKER_INC_HELD(mcbi)	(mcbi)->mcbi_walker_cnt++;
125 
126 #define	MAC_CALLBACK_WALKER_DCR(mcbi, headp) {			\
127 	mac_cb_t	*rmlist;				\
128 								\
129 	mutex_enter((mcbi)->mcbi_lockp);			\
130 	if (--(mcbi)->mcbi_walker_cnt == 0 && (mcbi)->mcbi_del_cnt != 0) { \
131 		rmlist = mac_callback_walker_cleanup((mcbi), headp);	\
132 		mac_callback_free(rmlist);			\
133 		cv_broadcast(&(mcbi)->mcbi_cv);			\
134 	}							\
135 	mutex_exit((mcbi)->mcbi_lockp);				\
136 }
137 
138 #define	MAC_PROMISC_WALKER_INC(mip)				\
139 	MAC_CALLBACK_WALKER_INC(&(mip)->mi_promisc_cb_info)
140 
141 #define	MAC_PROMISC_WALKER_DCR(mip) {				\
142 	mac_cb_info_t	*mcbi;					\
143 								\
144 	mcbi = &(mip)->mi_promisc_cb_info;			\
145 	mutex_enter(mcbi->mcbi_lockp);				\
146 	if (--mcbi->mcbi_walker_cnt == 0 && mcbi->mcbi_del_cnt != 0) { \
147 		i_mac_promisc_walker_cleanup(mip);		\
148 		cv_broadcast(&mcbi->mcbi_cv);			\
149 	}							\
150 	mutex_exit(mcbi->mcbi_lockp);				\
151 }
152 
153 typedef struct mactype_s {
154 	const char	*mt_ident;
155 	uint32_t	mt_ref;
156 	uint_t		mt_type;
157 	uint_t		mt_nativetype;
158 	size_t		mt_addr_length;
159 	uint8_t		*mt_brdcst_addr;
160 	mactype_ops_t	mt_ops;
161 	mac_stat_info_t	*mt_stats;	/* array of mac_stat_info_t elements */
162 	size_t		mt_statcount;	/* number of elements in mt_stats */
163 	mac_ndd_mapping_t *mt_mapping;
164 	size_t		mt_mappingcount;
165 } mactype_t;
166 
167 /*
168  * Multiple rings implementation.
169  */
170 typedef	enum {
171 	MAC_GROUP_STATE_UNINIT	= 0,	/* initial state of data structure */
172 	MAC_GROUP_STATE_REGISTERED,	/* hooked with h/w group */
173 	MAC_GROUP_STATE_RESERVED,	/* group is reserved and opened */
174 	MAC_GROUP_STATE_SHARED		/* default group shared among */
175 					/* multiple mac clients */
176 } mac_group_state_t;
177 
178 typedef	struct mac_ring_s mac_ring_t;
179 typedef	struct mac_group_s mac_group_t;
180 
181 /*
182  * Ring data structure for ring control and management.
183  */
184 typedef enum {
185 	MR_FREE,		/* Available for assignment to flows */
186 	MR_NEWLY_ADDED,		/* Just assigned to another group */
187 	MR_INUSE		/* Assigned to an SRS */
188 } mac_ring_state_t;
189 
190 /* mr_flag values */
191 #define	MR_INCIPIENT	0x1
192 #define	MR_CONDEMNED	0x2
193 #define	MR_QUIESCE	0x4
194 
195 typedef struct mac_impl_s mac_impl_t;
196 
197 struct mac_ring_s {
198 	int			mr_index;	/* index in the original list */
199 	mac_ring_type_t		mr_type;	/* ring type */
200 	mac_ring_t		*mr_next;	/* next ring in the chain */
201 	mac_group_handle_t	mr_gh;		/* reference to group */
202 
203 	mac_classify_type_t	mr_classify_type;	/* HW vs SW */
204 	struct mac_soft_ring_set_s *mr_srs;	/* associated SRS */
205 	mac_ring_handle_t	mr_prh;		/* associated pseudo ring hdl */
206 	uint_t			mr_refcnt;	/* Ring references */
207 	/* ring generation no. to guard against drivers using stale rings */
208 	uint64_t		mr_gen_num;
209 
210 	kstat_t			*mr_ksp;	/* ring kstats */
211 	mac_impl_t		*mr_mip;	/* pointer to primary's mip */
212 
213 	kmutex_t		mr_lock;
214 	kcondvar_t		mr_cv;			/* mr_lock */
215 	mac_ring_state_t	mr_state;		/* mr_lock */
216 	uint_t			mr_flag;		/* mr_lock */
217 
218 	mac_ring_info_t		mr_info;	/* driver supplied info */
219 };
220 #define	mr_driver		mr_info.mri_driver
221 #define	mr_start		mr_info.mri_start
222 #define	mr_stop			mr_info.mri_stop
223 #define	mr_stat			mr_info.mri_stat
224 
225 #define	MAC_RING_MARK(mr, flag)		\
226 	(mr)->mr_flag |= flag;
227 
228 #define	MAC_RING_UNMARK(mr, flag)	\
229 	(mr)->mr_flag &= ~flag;
230 
231 /*
232  * Reference hold and release on mac_ring_t 'mr'
233  */
234 #define	MR_REFHOLD_LOCKED(mr)		{		\
235 	ASSERT(MUTEX_HELD(&mr->mr_lock));		\
236 	(mr)->mr_refcnt++;				\
237 }
238 
239 #define	MR_REFRELE(mr)		{	 		\
240 	mutex_enter(&(mr)->mr_lock);			\
241 	ASSERT((mr)->mr_refcnt != 0);			\
242 	(mr)->mr_refcnt--;				\
243 	if ((mr)->mr_refcnt == 0 &&			\
244 	    ((mr)->mr_flag & (MR_CONDEMNED | MR_QUIESCE))) \
245 		cv_signal(&(mr)->mr_cv);		\
246 	mutex_exit(&(mr)->mr_lock);			\
247 }
248 
249 /*
250  * Per mac client flow information associated with a RX group.
251  * The entire structure is SL protected.
252  */
253 typedef struct mac_grp_client {
254 	struct mac_grp_client		*mgc_next;
255 	struct mac_client_impl_s	*mgc_client;
256 } mac_grp_client_t;
257 
258 #define	MAC_GROUP_NO_CLIENT(g)	((g)->mrg_clients == NULL)
259 
260 #define	MAC_GROUP_ONLY_CLIENT(g)			\
261 	((((g)->mrg_clients != NULL) &&			\
262 	((g)->mrg_clients->mgc_next == NULL)) ?		\
263 	(g)->mrg_clients->mgc_client : NULL)
264 
265 /*
266  * Common ring group data structure for ring control and management.
267  * The entire structure is SL protected
268  */
269 struct mac_group_s {
270 	int			mrg_index;	/* index in the list */
271 	mac_ring_type_t		mrg_type;	/* ring type */
272 	mac_group_state_t	mrg_state;	/* state of the group */
273 	mac_group_t		*mrg_next;	/* next ring in the chain */
274 	mac_handle_t		mrg_mh;		/* reference to MAC */
275 	mac_ring_t		*mrg_rings;	/* grouped rings */
276 	uint_t			mrg_cur_count;	/* actual size of group */
277 
278 	mac_grp_client_t	*mrg_clients;	/* clients list */
279 
280 	mac_group_info_t	mrg_info;	/* driver supplied info */
281 };
282 
283 #define	mrg_driver		mrg_info.mgi_driver
284 #define	mrg_start		mrg_info.mgi_start
285 #define	mrg_stop		mrg_info.mgi_stop
286 
287 #define	GROUP_INTR_HANDLE(g)		(g)->mrg_info.mgi_intr.mi_handle
288 #define	GROUP_INTR_ENABLE_FUNC(g)	(g)->mrg_info.mgi_intr.mi_enable
289 #define	GROUP_INTR_DISABLE_FUNC(g)	(g)->mrg_info.mgi_intr.mi_disable
290 
291 #define	MAC_RING_TX(mhp, rh, mp, rest) {				\
292 	mac_ring_handle_t mrh = rh;					\
293 	mac_impl_t *mimpl = (mac_impl_t *)mhp;				\
294 	/*								\
295 	 * Send packets through a selected tx ring, or through the 	\
296 	 * default handler if there is no selected ring.		\
297 	 */								\
298 	if (mrh == NULL)						\
299 		mrh = mimpl->mi_default_tx_ring;			\
300 	if (mrh == NULL) {						\
301 		rest = mimpl->mi_tx(mimpl->mi_driver, mp);		\
302 	} else {							\
303 		rest = mac_hwring_tx(mrh, mp);				\
304 	}								\
305 }
306 
307 /*
308  * This is the final stop before reaching the underlying driver
309  * or aggregation, so this is where the bridging hook is implemented.
310  * Packets that are bridged will return through mac_bridge_tx(), with
311  * rh nulled out if the bridge chooses to send output on a different
312  * link due to forwarding.
313  */
314 #define	MAC_TX(mip, rh, mp, src_mcip) {					\
315 	mac_ring_handle_t	rhandle = (rh);				\
316 	/*								\
317 	 * If there is a bound Hybrid I/O share, send packets through 	\
318 	 * the default tx ring. (When there's a bound Hybrid I/O share,	\
319 	 * the tx rings of this client are mapped in the guest domain 	\
320 	 * and not accessible from here.)				\
321 	 */								\
322 	_NOTE(CONSTANTCONDITION)					\
323 	if ((src_mcip)->mci_state_flags & MCIS_SHARE_BOUND)		\
324 		rhandle = (mip)->mi_default_tx_ring;			\
325 	if (mip->mi_promisc_list != NULL)				\
326 		mac_promisc_dispatch(mip, mp, src_mcip);		\
327 	/*								\
328 	 * Grab the proper transmit pointer and handle. Special 	\
329 	 * optimization: we can test mi_bridge_link itself atomically,	\
330 	 * and if that indicates no bridge send packets through tx ring.\
331 	 */								\
332 	if (mip->mi_bridge_link == NULL) {				\
333 		MAC_RING_TX(mip, rhandle, mp, mp);			\
334 	} else {							\
335 		mp = mac_bridge_tx(mip, rhandle, mp);			\
336 	}								\
337 }
338 
339 /* mci_tx_flag */
340 #define	MCI_TX_QUIESCE	0x1
341 
342 typedef struct mac_factory_addr_s {
343 	boolean_t		mfa_in_use;
344 	uint8_t			mfa_addr[MAXMACADDRLEN];
345 	struct mac_client_impl_s	*mfa_client;
346 } mac_factory_addr_t;
347 
348 typedef struct mac_mcast_addrs_s {
349 	struct mac_mcast_addrs_s	*mma_next;
350 	uint8_t				mma_addr[MAXMACADDRLEN];
351 	int				mma_ref;
352 } mac_mcast_addrs_t;
353 
354 typedef enum {
355 	MAC_ADDRESS_TYPE_UNICAST_CLASSIFIED = 1,	/* hardware steering */
356 	MAC_ADDRESS_TYPE_UNICAST_PROMISC		/* promiscuous mode */
357 } mac_address_type_t;
358 
359 typedef struct mac_address_s {
360 	mac_address_type_t	ma_type;		/* address type */
361 	int			ma_nusers;		/* number of users */
362 							/* of that address */
363 	struct mac_address_s	*ma_next;		/* next address */
364 	uint8_t			ma_addr[MAXMACADDRLEN];	/* address value */
365 	size_t			ma_len;			/* address length */
366 	mac_group_t		*ma_group;		/* asscociated group */
367 	mac_impl_t		*ma_mip;		/* MAC handle */
368 } mac_address_t;
369 
370 extern krwlock_t i_mac_impl_lock;
371 extern mod_hash_t *i_mac_impl_hash;
372 extern kmem_cache_t *i_mac_impl_cachep;
373 extern uint_t i_mac_impl_count;
374 
375 /*
376  * Each registered MAC is associated with a mac_impl_t structure. The
377  * structure represents the undelying hardware, in terms of definition,
378  * resources (transmit, receive rings etc.), callback functions etc. It
379  * also holds the table of MAC clients that are configured on the device.
380  * The table is used for classifying incoming packets in software.
381  *
382  * The protection scheme uses 2 elements, a coarse serialization mechanism
383  * called perimeter and a finer traditional lock based scheme. More details
384  * can be found in the big block comment in mac.c.
385  *
386  * The protection scheme for each member of the mac_impl_t is described below.
387  *
388  * Write Once Only (WO): Typically these don't change for the lifetime of the
389  * data structure. For example something in mac_impl_t that stays the same
390  * from mac_register to mac_unregister, or something in a mac_client_impl_t
391  * that stays the same from mac_client_open to mac_client_close.
392  *
393  * Serializer (SL): Protected by the Serializer. All SLOP operations on a
394  * mac endpoint go through the serializer. MTOPs don't care about reading
395  * these fields atomically.
396  *
397  * Lock: Traditional mutex/rw lock. Modify operations still go through the
398  * mac serializer, the lock helps synchronize readers with writers.
399  */
400 struct mac_impl_s {
401 	krwlock_t		mi_rw_lock;
402 	list_node_t		mi_node;
403 	char			mi_name[LIFNAMSIZ];	/* WO */
404 	uint32_t		mi_state_flags;
405 	void			*mi_driver;		/* Driver private, WO */
406 	mac_info_t		mi_info;		/* WO */
407 	mactype_t		*mi_type;		/* WO */
408 	void			*mi_pdata;		/* WO */
409 	size_t			mi_pdata_size;		/* WO */
410 	mac_callbacks_t		*mi_callbacks;		/* WO */
411 	dev_info_t		*mi_dip;		/* WO */
412 	uint32_t		mi_ref;			/* i_mac_impl_lock */
413 	uint_t			mi_active;		/* SL */
414 	link_state_t		mi_linkstate;		/* none */
415 	link_state_t		mi_lowlinkstate;	/* none */
416 	link_state_t		mi_lastlowlinkstate;	/* none */
417 	uint_t			mi_devpromisc;		/* SL */
418 	uint8_t			mi_addr[MAXMACADDRLEN];	/* mi_rw_lock */
419 	uint8_t			mi_dstaddr[MAXMACADDRLEN]; /* mi_rw_lock */
420 	boolean_t		mi_dstaddr_set;
421 
422 	/*
423 	 * The mac perimeter. All client initiated create/modify operations
424 	 * on a mac end point go through this.
425 	 */
426 	kmutex_t		mi_perim_lock;
427 	kthread_t		*mi_perim_owner;	/* mi_perim_lock */
428 	uint_t			mi_perim_ocnt;		/* mi_perim_lock */
429 	kcondvar_t		mi_perim_cv;		/* mi_perim_lock */
430 
431 	/* mac notification callbacks */
432 	kmutex_t		mi_notify_lock;
433 	mac_cb_info_t		mi_notify_cb_info;	/* mi_notify_lock */
434 	mac_cb_t		*mi_notify_cb_list;	/* mi_notify_lock */
435 	kthread_t		*mi_notify_thread;	/* mi_notify_lock */
436 	uint_t			mi_notify_bits;		/* mi_notify_lock */
437 
438 	uint32_t		mi_v12n_level;		/* Virt'ion readiness */
439 
440 	/*
441 	 * RX groups, ring capability
442 	 * Fields of this block are SL protected.
443 	 */
444 	mac_group_type_t	mi_rx_group_type;	/* grouping type */
445 	uint_t			mi_rx_group_count;
446 	mac_group_t		*mi_rx_groups;
447 	mac_group_t		*mi_rx_donor_grp;
448 	uint_t			mi_rxrings_rsvd;
449 	uint_t			mi_rxrings_avail;
450 	uint_t			mi_rxhwclnt_avail;
451 	uint_t			mi_rxhwclnt_used;
452 
453 	mac_capab_rings_t	mi_rx_rings_cap;
454 
455 	/*
456 	 * TX groups and ring capability, SL Protected.
457 	 */
458 	mac_group_type_t	mi_tx_group_type;	/* grouping type */
459 	uint_t			mi_tx_group_count;
460 	uint_t			mi_tx_group_free;
461 	mac_group_t		*mi_tx_groups;
462 	mac_capab_rings_t	mi_tx_rings_cap;
463 	uint_t			mi_txrings_rsvd;
464 	uint_t			mi_txrings_avail;
465 	uint_t			mi_txhwclnt_avail;
466 	uint_t			mi_txhwclnt_used;
467 
468 	mac_ring_handle_t	mi_default_tx_ring;
469 
470 	/*
471 	 * MAC address list. SL protected.
472 	 */
473 	mac_address_t		*mi_addresses;
474 
475 	/*
476 	 * This MAC's table of sub-flows
477 	 */
478 	flow_tab_t		*mi_flow_tab;		/* WO */
479 
480 	kstat_t			*mi_ksp;		/* WO */
481 	uint_t			mi_kstat_count;		/* WO */
482 	uint_t			mi_nactiveclients;	/* SL */
483 
484 	/* for broadcast and multicast support */
485 	struct mac_mcast_addrs_s *mi_mcast_addrs;	/* mi_rw_lock */
486 	struct mac_bcast_grp_s *mi_bcast_grp;		/* mi_rw_lock */
487 	uint_t			mi_bcast_ngrps;		/* mi_rw_lock */
488 
489 	/* list of MAC clients which opened this MAC */
490 	struct mac_client_impl_s *mi_clients_list;	/* mi_rw_lock */
491 	uint_t			mi_nclients;		/* mi_rw_lock */
492 	struct mac_client_impl_s *mi_single_active_client; /* mi_rw_lock */
493 
494 	uint32_t		mi_margin;		/* mi_rw_lock */
495 	uint_t			mi_sdu_min;		/* mi_rw_lock */
496 	uint_t			mi_sdu_max;		/* mi_rw_lock */
497 	uint_t			mi_sdu_multicast;	/* mi_rw_lock */
498 
499 	/*
500 	 * Cache of factory MAC addresses provided by the driver. If
501 	 * the driver doesn't provide multiple factory MAC addresses,
502 	 * the mi_factory_addr is set to NULL, and mi_factory_addr_num
503 	 * is set to zero.
504 	 */
505 	mac_factory_addr_t	*mi_factory_addr;	/* mi_rw_lock */
506 	uint_t			mi_factory_addr_num;	/* mi_rw_lock */
507 
508 	/* for promiscuous mode support */
509 	kmutex_t		mi_promisc_lock;
510 	mac_cb_t		*mi_promisc_list;	/* mi_promisc_lock */
511 	mac_cb_info_t		mi_promisc_cb_info;	/* mi_promisc_lock */
512 
513 	/* cache of rings over this mac_impl */
514 	kmutex_t		mi_ring_lock;
515 	mac_ring_t		*mi_ring_freelist;	/* mi_ring_lock */
516 
517 	/*
518 	 * These are used for caching the properties, if any, for the
519 	 * primary MAC client. If the MAC client is not yet in place
520 	 * when the properties are set then we cache them here to be
521 	 * applied to the MAC client when it is created.
522 	 */
523 	mac_resource_props_t	mi_resource_props;	/* SL */
524 	uint16_t		mi_pvid;		/* SL */
525 
526 	minor_t			mi_minor;		/* WO */
527 	uint32_t		mi_oref;		/* SL */
528 	mac_capab_legacy_t	mi_capab_legacy;	/* WO */
529 	dev_t			mi_phy_dev;		/* WO */
530 
531 	/*
532 	 * List of margin value requests added by mac clients. This list is
533 	 * sorted: the first one has the greatest value.
534 	 */
535 	mac_margin_req_t	*mi_mmrp;
536 	char			**mi_priv_prop;
537 	uint_t			mi_priv_prop_count;
538 
539 	/*
540 	 * Hybrid I/O related definitions.
541 	 */
542 	mac_capab_share_t	mi_share_capab;
543 
544 	/*
545 	 * Bridging hooks and limit values.  Uses mutex and reference counts
546 	 * (bridging only) for data path.  Limits need no synchronization.
547 	 */
548 	mac_handle_t		mi_bridge_link;
549 	kmutex_t		mi_bridge_lock;
550 	uint32_t		mi_llimit;
551 	uint32_t		mi_ldecay;
552 
553 /* This should be the last block in this structure */
554 #ifdef DEBUG
555 #define	MAC_PERIM_STACK_DEPTH	15
556 	int			mi_perim_stack_depth;
557 	pc_t			mi_perim_stack[MAC_PERIM_STACK_DEPTH];
558 #endif
559 };
560 
561 /*
562  * The default TX group is the last one in the list.
563  */
564 #define	MAC_DEFAULT_TX_GROUP(mip)	\
565 	(mip)->mi_tx_groups + (mip)->mi_tx_group_count
566 
567 /*
568  * The default RX group is the first one in the list
569  */
570 #define	MAC_DEFAULT_RX_GROUP(mip)	(mip)->mi_rx_groups
571 
572 /* Reserved RX rings */
573 #define	MAC_RX_RING_RESERVED(m, cnt)	{	\
574 	ASSERT((m)->mi_rxrings_avail >= (cnt));	\
575 	(m)->mi_rxrings_rsvd += (cnt);		\
576 	(m)->mi_rxrings_avail -= (cnt);		\
577 }
578 
579 /* Released RX rings */
580 #define	MAC_RX_RING_RELEASED(m, cnt)	{	\
581 	ASSERT((m)->mi_rxrings_rsvd >= (cnt));	\
582 	(m)->mi_rxrings_rsvd -= (cnt);		\
583 	(m)->mi_rxrings_avail += (cnt);		\
584 }
585 
586 /* Reserved a RX group */
587 #define	MAC_RX_GRP_RESERVED(m)	{		\
588 	ASSERT((m)->mi_rxhwclnt_avail > 0);	\
589 	(m)->mi_rxhwclnt_avail--;		\
590 	(m)->mi_rxhwclnt_used++;		\
591 }
592 
593 /* Released a RX group */
594 #define	MAC_RX_GRP_RELEASED(m)	{		\
595 	ASSERT((m)->mi_rxhwclnt_used > 0);	\
596 	(m)->mi_rxhwclnt_avail++;		\
597 	(m)->mi_rxhwclnt_used--;		\
598 }
599 
600 /* Reserved TX rings */
601 #define	MAC_TX_RING_RESERVED(m, cnt)	{	\
602 	ASSERT((m)->mi_txrings_avail >= (cnt));	\
603 	(m)->mi_txrings_rsvd += (cnt);		\
604 	(m)->mi_txrings_avail -= (cnt);		\
605 }
606 /* Released TX rings */
607 #define	MAC_TX_RING_RELEASED(m, cnt)	{	\
608 	ASSERT((m)->mi_txrings_rsvd >= (cnt));	\
609 	(m)->mi_txrings_rsvd -= (cnt);		\
610 	(m)->mi_txrings_avail += (cnt);		\
611 }
612 
613 /* Reserved a TX group */
614 #define	MAC_TX_GRP_RESERVED(m)	{		\
615 	ASSERT((m)->mi_txhwclnt_avail > 0);	\
616 	(m)->mi_txhwclnt_avail--;		\
617 	(m)->mi_txhwclnt_used++;		\
618 }
619 
620 /* Released a TX group */
621 #define	MAC_TX_GRP_RELEASED(m)	{		\
622 	ASSERT((m)->mi_txhwclnt_used > 0);	\
623 	(m)->mi_txhwclnt_avail++;		\
624 	(m)->mi_txhwclnt_used--;		\
625 }
626 
627 /* for mi_state_flags */
628 #define	MIS_DISABLED		0x0001
629 #define	MIS_IS_VNIC		0x0002
630 #define	MIS_IS_AGGR		0x0004
631 #define	MIS_NOTIFY_DONE		0x0008
632 #define	MIS_EXCLUSIVE		0x0010
633 #define	MIS_EXCLUSIVE_HELD	0x0020
634 #define	MIS_LEGACY		0x0040
635 #define	MIS_NO_ACTIVE		0x0080
636 #define	MIS_POLL_DISABLE	0x0100
637 
638 #define	mi_getstat	mi_callbacks->mc_getstat
639 #define	mi_start	mi_callbacks->mc_start
640 #define	mi_stop		mi_callbacks->mc_stop
641 #define	mi_open		mi_callbacks->mc_open
642 #define	mi_close	mi_callbacks->mc_close
643 #define	mi_setpromisc	mi_callbacks->mc_setpromisc
644 #define	mi_multicst	mi_callbacks->mc_multicst
645 #define	mi_unicst	mi_callbacks->mc_unicst
646 #define	mi_tx		mi_callbacks->mc_tx
647 #define	mi_ioctl	mi_callbacks->mc_ioctl
648 #define	mi_getcapab	mi_callbacks->mc_getcapab
649 
650 typedef struct mac_notify_task_arg {
651 	mac_impl_t		*mnt_mip;
652 	mac_notify_type_t	mnt_type;
653 	mac_ring_t		*mnt_ring;
654 } mac_notify_task_arg_t;
655 
656 /*
657  * XXX All MAC_DBG_PRTs must be replaced with call to dtrace probes. For now
658  * it may be easier to have these printfs for easier debugging
659  */
660 #ifdef DEBUG
661 extern int mac_dbg;
662 #define	MAC_DBG_PRT(a)	if (mac_dbg > 0) {(void) printf a; }
663 #else
664 #define	MAC_DBG_PRT(a)
665 #endif
666 
667 /*
668  * The mac_perim_handle_t is an opaque type that encodes the 'mip' pointer
669  * and whether internally a mac_open was done when acquiring the perimeter.
670  */
671 #define	MAC_ENCODE_MPH(mph, mh, need_close)		\
672 	(mph) = (mac_perim_handle_t)((uintptr_t)(mh) | need_close)
673 
674 #define	MAC_DECODE_MPH(mph, mip, need_close) {		\
675 	mip = (mac_impl_t *)(((uintptr_t)mph) & ~0x1);	\
676 	(need_close) = ((uintptr_t)mph & 0x1);		\
677 }
678 
679 /*
680  * Type of property information that can be returned by a driver.
681  * Valid flags of the pr_flags of the mac_prop_info_t data structure.
682  */
683 #define	MAC_PROP_INFO_DEFAULT	0x0001
684 #define	MAC_PROP_INFO_RANGE	0x0002
685 #define	MAC_PROP_INFO_PERM	0x0004
686 
687 /*
688  * Property information. pr_flags is a combination of one of the
689  * MAC_PROP_INFO_* flags, it is reset by the framework before invoking
690  * the driver's prefix_propinfo() entry point.
691  *
692  * Drivers should use MAC_PROP_INFO_SET_*() macros to provide
693  * information about a property.
694  */
695 typedef struct mac_prop_info_state_s {
696 	uint8_t			pr_flags;
697 	uint8_t			pr_perm;
698 	uint8_t			pr_errno;
699 	void			*pr_default;
700 	size_t			pr_default_size;
701 	mac_propval_range_t	*pr_range;
702 	uint_t			pr_range_cur_count;
703 } mac_prop_info_state_t;
704 
705 #define	MAC_PROTECT_ENABLED(mcip, type) \
706 	(((mcip)->mci_flent-> \
707 	fe_resource_props.mrp_mask & MRP_PROTECT) != 0 && \
708 	((mcip)->mci_flent-> \
709 	fe_resource_props.mrp_protect.mp_types & (type)) != 0)
710 
711 typedef struct mac_client_impl_s mac_client_impl_t;
712 
713 extern void	mac_init(void);
714 extern int	mac_fini(void);
715 
716 extern void	mac_ndd_ioctl(mac_impl_t *, queue_t *, mblk_t *);
717 extern boolean_t mac_ip_hdr_length_v6(ip6_t *, uint8_t *, uint16_t *,
718     uint8_t *, ip6_frag_t **);
719 
720 extern mblk_t *mac_copymsgchain_cksum(mblk_t *);
721 extern mblk_t *mac_fix_cksum(mblk_t *);
722 extern void mac_packet_print(mac_handle_t, mblk_t *);
723 extern void mac_rx_deliver(void *, mac_resource_handle_t, mblk_t *,
724     mac_header_info_t *);
725 extern void mac_tx_notify(mac_impl_t *);
726 
727 extern	boolean_t mac_callback_find(mac_cb_info_t *, mac_cb_t **, mac_cb_t *);
728 extern	void	mac_callback_add(mac_cb_info_t *, mac_cb_t **, mac_cb_t *);
729 extern	boolean_t mac_callback_remove(mac_cb_info_t *, mac_cb_t **, mac_cb_t *);
730 extern	void	mac_callback_remove_wait(mac_cb_info_t *);
731 extern	void	mac_callback_free(mac_cb_t *);
732 extern	mac_cb_t *mac_callback_walker_cleanup(mac_cb_info_t *, mac_cb_t **);
733 
734 /* in mac_bcast.c */
735 extern void mac_bcast_init(void);
736 extern void mac_bcast_fini(void);
737 extern mac_impl_t *mac_bcast_grp_mip(void *);
738 extern int mac_bcast_add(mac_client_impl_t *, const uint8_t *, uint16_t,
739     mac_addrtype_t);
740 extern void mac_bcast_delete(mac_client_impl_t *, const uint8_t *, uint16_t);
741 extern void mac_bcast_send(void *, void *, mblk_t *, boolean_t);
742 extern void mac_bcast_grp_free(void *);
743 extern void mac_bcast_refresh(mac_impl_t *, mac_multicst_t, void *,
744     boolean_t);
745 extern void mac_client_bcast_refresh(mac_client_impl_t *, mac_multicst_t,
746     void *, boolean_t);
747 
748 /*
749  * Grouping functions are used internally by MAC layer.
750  */
751 extern int mac_group_addmac(mac_group_t *, const uint8_t *);
752 extern int mac_group_remmac(mac_group_t *, const uint8_t *);
753 extern int mac_rx_group_add_flow(mac_client_impl_t *, flow_entry_t *,
754     mac_group_t *);
755 extern mblk_t *mac_hwring_tx(mac_ring_handle_t, mblk_t *);
756 extern mblk_t *mac_bridge_tx(mac_impl_t *, mac_ring_handle_t, mblk_t *);
757 extern mac_group_t *mac_reserve_rx_group(mac_client_impl_t *, uint8_t *,
758     boolean_t);
759 extern void mac_release_rx_group(mac_client_impl_t *, mac_group_t *);
760 extern int mac_rx_switch_group(mac_client_impl_t *, mac_group_t *,
761     mac_group_t *);
762 extern mac_ring_t *mac_reserve_tx_ring(mac_impl_t *, mac_ring_t *);
763 extern mac_group_t *mac_reserve_tx_group(mac_client_impl_t *, boolean_t);
764 extern void mac_release_tx_group(mac_client_impl_t *, mac_group_t *);
765 extern void mac_tx_switch_group(mac_client_impl_t *, mac_group_t *,
766     mac_group_t *);
767 extern void mac_rx_switch_grp_to_sw(mac_group_t *);
768 
769 /*
770  * MAC address functions are used internally by MAC layer.
771  */
772 extern mac_address_t *mac_find_macaddr(mac_impl_t *, uint8_t *);
773 extern boolean_t mac_check_macaddr_shared(mac_address_t *);
774 extern int mac_update_macaddr(mac_address_t *, uint8_t *);
775 extern void mac_freshen_macaddr(mac_address_t *, uint8_t *);
776 extern void mac_retrieve_macaddr(mac_address_t *, uint8_t *);
777 extern void mac_init_macaddr(mac_impl_t *);
778 extern void mac_fini_macaddr(mac_impl_t *);
779 
780 /*
781  * Flow construction/destruction routines.
782  * Not meant to be used by mac clients.
783  */
784 extern int mac_link_flow_init(mac_client_handle_t, flow_entry_t *);
785 extern void mac_link_flow_clean(mac_client_handle_t, flow_entry_t *);
786 
787 /*
788  * Fanout update routines called when the link speed of the NIC changes
789  * or when a MAC client's share is unbound.
790  */
791 extern void mac_fanout_recompute_client(mac_client_impl_t *, cpupart_t *);
792 extern void mac_fanout_recompute(mac_impl_t *);
793 
794 /*
795  * The following functions are used internally by the MAC layer to
796  * add/remove/update flows associated with a mac_impl_t. They should
797  * never be used directly by MAC clients.
798  */
799 extern int mac_datapath_setup(mac_client_impl_t *, flow_entry_t *, uint32_t);
800 extern void mac_datapath_teardown(mac_client_impl_t *, flow_entry_t *,
801     uint32_t);
802 extern void mac_rx_srs_group_setup(mac_client_impl_t *, flow_entry_t *,
803     uint32_t);
804 extern void mac_tx_srs_group_setup(mac_client_impl_t *, flow_entry_t *,
805     uint32_t);
806 extern void mac_rx_srs_group_teardown(flow_entry_t *, boolean_t);
807 extern void mac_tx_srs_group_teardown(mac_client_impl_t *, flow_entry_t *,
808 	    uint32_t);
809 extern int mac_rx_classify_flow_quiesce(flow_entry_t *, void *);
810 extern int mac_rx_classify_flow_restart(flow_entry_t *, void *);
811 extern void mac_client_quiesce(mac_client_impl_t *);
812 extern void mac_client_restart(mac_client_impl_t *);
813 
814 extern void mac_flow_update_priority(mac_client_impl_t *, flow_entry_t *);
815 
816 extern void mac_flow_rem_subflow(flow_entry_t *);
817 extern void mac_rename_flow(flow_entry_t *, const char *);
818 extern void mac_flow_set_name(flow_entry_t *, const char *);
819 
820 extern mblk_t *mac_add_vlan_tag(mblk_t *, uint_t, uint16_t);
821 extern mblk_t *mac_add_vlan_tag_chain(mblk_t *, uint_t, uint16_t);
822 extern mblk_t *mac_strip_vlan_tag_chain(mblk_t *);
823 extern void mac_pkt_drop(void *, mac_resource_handle_t, mblk_t *, boolean_t);
824 extern mblk_t *mac_rx_flow(mac_handle_t, mac_resource_handle_t, mblk_t *);
825 
826 extern void i_mac_share_alloc(mac_client_impl_t *);
827 extern void i_mac_share_free(mac_client_impl_t *);
828 extern void i_mac_perim_enter(mac_impl_t *);
829 extern void i_mac_perim_exit(mac_impl_t *);
830 extern int i_mac_perim_enter_nowait(mac_impl_t *);
831 extern void i_mac_tx_srs_notify(mac_impl_t *, mac_ring_handle_t);
832 extern int mac_hold(const char *, mac_impl_t **);
833 extern void mac_rele(mac_impl_t *);
834 extern int i_mac_disable(mac_impl_t *);
835 extern void i_mac_notify(mac_impl_t *, mac_notify_type_t);
836 extern void i_mac_notify_exit(mac_impl_t *);
837 extern void mac_rx_group_unmark(mac_group_t *, uint_t);
838 extern void mac_tx_client_flush(mac_client_impl_t *);
839 extern void mac_tx_client_block(mac_client_impl_t *);
840 extern void mac_tx_client_unblock(mac_client_impl_t *);
841 extern void mac_tx_invoke_callbacks(mac_client_impl_t *, mac_tx_cookie_t);
842 extern int i_mac_promisc_set(mac_impl_t *, boolean_t);
843 extern void i_mac_promisc_walker_cleanup(mac_impl_t *);
844 extern mactype_t *mactype_getplugin(const char *);
845 extern void mac_addr_factory_init(mac_impl_t *);
846 extern void mac_addr_factory_fini(mac_impl_t *);
847 extern void mac_register_priv_prop(mac_impl_t *, char **);
848 extern void mac_unregister_priv_prop(mac_impl_t *);
849 extern int mac_init_rings(mac_impl_t *, mac_ring_type_t);
850 extern void mac_free_rings(mac_impl_t *, mac_ring_type_t);
851 extern void mac_compare_ddi_handle(mac_group_t *, uint_t, mac_ring_t *);
852 
853 extern int mac_start_group(mac_group_t *);
854 extern void mac_stop_group(mac_group_t *);
855 extern int mac_start_ring(mac_ring_t *);
856 extern void mac_stop_ring(mac_ring_t *);
857 extern int mac_add_macaddr(mac_impl_t *, mac_group_t *, uint8_t *, boolean_t);
858 extern int mac_remove_macaddr(mac_address_t *);
859 
860 extern void mac_set_group_state(mac_group_t *, mac_group_state_t);
861 extern void mac_group_add_client(mac_group_t *, mac_client_impl_t *);
862 extern void mac_group_remove_client(mac_group_t *, mac_client_impl_t *);
863 
864 extern int i_mac_group_add_ring(mac_group_t *, mac_ring_t *, int);
865 extern void i_mac_group_rem_ring(mac_group_t *, mac_ring_t *, boolean_t);
866 extern int mac_group_ring_modify(mac_client_impl_t *, mac_group_t *,
867     mac_group_t *);
868 extern void mac_poll_state_change(mac_handle_t, boolean_t);
869 
870 extern mac_group_state_t mac_group_next_state(mac_group_t *,
871     mac_client_impl_t **, mac_group_t *, boolean_t);
872 
873 extern mblk_t *mac_protect_check(mac_client_handle_t, mblk_t *);
874 extern int mac_protect_set(mac_client_handle_t, mac_resource_props_t *);
875 extern boolean_t mac_protect_enabled(mac_client_handle_t, uint32_t);
876 extern int mac_protect_validate(mac_resource_props_t *);
877 extern void mac_protect_update(mac_resource_props_t *, mac_resource_props_t *);
878 extern void mac_protect_update_v6_local_addr(mac_client_impl_t *);
879 extern void mac_protect_intercept_dhcp(mac_client_impl_t *, mblk_t *);
880 extern void mac_protect_flush_dhcp(mac_client_impl_t *);
881 extern void mac_protect_cancel_timer(mac_client_impl_t *);
882 extern void mac_protect_init(mac_client_impl_t *);
883 extern void mac_protect_fini(mac_client_impl_t *);
884 
885 extern int mac_set_resources(mac_handle_t, mac_resource_props_t *);
886 extern void mac_get_resources(mac_handle_t, mac_resource_props_t *);
887 extern void mac_get_effective_resources(mac_handle_t, mac_resource_props_t *);
888 
889 extern cpupart_t *mac_pset_find(mac_resource_props_t *, boolean_t *);
890 extern void mac_set_pool_effective(boolean_t, cpupart_t *,
891     mac_resource_props_t *, mac_resource_props_t *);
892 extern void mac_set_rings_effective(mac_client_impl_t *);
893 extern mac_client_impl_t *mac_check_primary_relocation(mac_client_impl_t *,
894     boolean_t);
895 
896 /* Global callbacks into the bridging module (when loaded) */
897 extern mac_bridge_tx_t mac_bridge_tx_cb;
898 extern mac_bridge_rx_t mac_bridge_rx_cb;
899 extern mac_bridge_ref_t mac_bridge_ref_cb;
900 extern mac_bridge_ls_t mac_bridge_ls_cb;
901 
902 
903 #ifdef	__cplusplus
904 }
905 #endif
906 
907 #endif	/* _SYS_MAC_IMPL_H */
908