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