xref: /illumos-gate/usr/src/uts/common/sys/dld_impl.h (revision 8648b7db)
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_DLD_IMPL_H
27 #define	_SYS_DLD_IMPL_H
28 
29 #include <sys/types.h>
30 #include <sys/list.h>
31 #include <sys/ethernet.h>
32 #include <sys/stream.h>
33 #include <sys/dlpi.h>
34 #include <sys/dld.h>
35 #include <sys/dls_impl.h>
36 
37 #ifdef	__cplusplus
38 extern "C" {
39 #endif
40 
41 #define	DLD_CONTROL_MINOR_NAME	"ctl"
42 #define	DLD_CONTROL_MINOR	0
43 
44 #define	DLD_CONTROL	0x00000001
45 #define	DLD_DLPI	0x00000002
46 
47 typedef enum {
48 	DLD_UNITDATA,
49 	DLD_FASTPATH,
50 	DLD_RAW
51 } dld_str_mode_t;
52 
53 typedef enum {
54 	DLD_UNINITIALIZED,
55 	DLD_PASSIVE,
56 	DLD_ACTIVE
57 } dld_passivestate_t;
58 
59 /*
60  * The dld_str_t object definition and protection scheme for each member
61  * is described below. The framework locking mechanism details are described in
62  * mac_impl.h and mac.c
63  *
64  * Write Once Only (WO): Typically these are initialized when the end point
65  * is created or initialized and don't change subsequently
66  *
67  * Serializer (SL): Protected by the Serializer. All modify operations on an
68  * end point go through the serializer. Readers don't care about reading
69  * these fields atomically, or readers also use the serializer to see the
70  * values atomically.
71  *
72  * Lock: kmutex_t or kwrlock_t lock. Modify operations still go through the
73  * serializer, the lock helps synchronize readers with writers.
74  */
75 
76 struct dld_str_s {					/* Protected by */
77 	/*
78 	 * Major number of the device
79 	 */
80 	major_t			ds_major;		/* WO */
81 
82 	/*
83 	 * Ephemeral minor number for the object.
84 	 */
85 	minor_t			ds_minor;		/* WO */
86 
87 	/*
88 	 * PPA number this stream is attached to.
89 	 */
90 	t_uscalar_t		ds_ppa;			/* SL */
91 
92 	/*
93 	 * Read/write queues for the stream which the object represents.
94 	 */
95 	queue_t			*ds_rq;			/* WO */
96 	queue_t			*ds_wq;			/* WO */
97 
98 	/*
99 	 * Stream is open to DLD_CONTROL (control node) or
100 	 * DLD_DLPI (DLS provider) node.
101 	 */
102 	uint_t			ds_type;		/* WO */
103 
104 	/*
105 	 * The following fields are only used for DLD_DLPI type objects.
106 	 */
107 
108 	/*
109 	 * Current DLPI state.
110 	 */
111 	t_uscalar_t		ds_dlstate;		/* SL */
112 
113 	/*
114 	 * DLPI style
115 	 */
116 	t_uscalar_t		ds_style;		/* WO */
117 
118 	/*
119 	 * Currently bound DLSAP.
120 	 */
121 	uint16_t		ds_sap;			/* SL */
122 
123 	/*
124 	 * Handle of the MAC that is used by the data-link interface.
125 	 */
126 	mac_handle_t		ds_mh;			/* SL */
127 	mac_client_handle_t	ds_mch;			/* SL */
128 
129 	/*
130 	 * Promiscuity level information.
131 	 */
132 	uint32_t		ds_promisc;		/* SL */
133 	mac_promisc_handle_t	ds_mph;
134 	mac_promisc_handle_t	ds_vlan_mph;
135 
136 	/*
137 	 * Immutable information of the MAC which the channel is using.
138 	 */
139 	const mac_info_t	*ds_mip;		/* SL */
140 
141 	/*
142 	 * Current packet priority.
143 	 */
144 	uint_t			ds_pri;			/* SL */
145 
146 	/*
147 	 * Handle of our MAC notification callback.
148 	 */
149 	mac_notify_handle_t	ds_mnh;			/* SL */
150 
151 	/*
152 	 * Set of enabled DL_NOTE... notifications. (See dlpi.h).
153 	 */
154 	uint32_t		ds_notifications;	/* SL */
155 
156 	/*
157 	 * Mode: unitdata, fast-path or raw.
158 	 */
159 	dld_str_mode_t		ds_mode;		/* SL */
160 
161 	/*
162 	 * Native mode state.
163 	 */
164 	boolean_t		ds_native;		/* SL */
165 
166 	/*
167 	 * IP polling is operational if this flag is set.
168 	 */
169 	boolean_t		ds_polling;		/* SL */
170 	boolean_t		ds_direct;		/* SL */
171 
172 	/*
173 	 * LSO is enabled if ds_lso is set.
174 	 */
175 	boolean_t		ds_lso;			/* SL */
176 	uint64_t		ds_lso_max;		/* SL */
177 
178 	/*
179 	 * State of DLPI user: may be active (regular network layer),
180 	 * passive (snoop-like monitoring), or unknown (not yet
181 	 * determined).
182 	 */
183 	dld_passivestate_t	ds_passivestate;	/* SL */
184 
185 	/*
186 	 * Dummy mblk used for flow-control.
187 	 */
188 	mblk_t			*ds_tx_flow_mp;		/* ds_lock */
189 
190 	/*
191 	 * List of queued DLPI requests. These will be processed
192 	 * by a taskq thread. This block is protected by ds_lock
193 	 */
194 	kmutex_t		ds_lock;
195 	krwlock_t		ds_rw_lock;
196 	kcondvar_t		ds_datathr_cv;		/* ds_lock */
197 	uint_t			ds_datathr_cnt;		/* ds_lock */
198 	mblk_t			*ds_pending_head;	/* ds_lock */
199 	mblk_t			*ds_pending_tail;	/* ds_lock */
200 	kcondvar_t		ds_dlpi_pending_cv;	/* ds_lock */
201 	uint32_t
202 				ds_dlpi_pending : 1,	/* ds_lock */
203 				ds_local	: 1,
204 				ds_pad		: 30;	/* ds_lock */
205 
206 	dls_link_t		*ds_dlp;		/* SL */
207 	dls_multicst_addr_t	*ds_dmap;		/* ds_rw_lock */
208 	dls_rx_t		ds_rx;			/* ds_lock */
209 	void			*ds_rx_arg;		/* ds_lock */
210 	uint_t			ds_nactive;		/* SL */
211 	dld_str_t		*ds_next;		/* SL */
212 	dls_head_t		*ds_head;
213 	dls_dl_handle_t		ds_ddh;
214 	list_node_t		ds_tqlist;
215 
216 	/*
217 	 * driver private data set by the driver when calling dld_str_open().
218 	 */
219 	void			*ds_private;
220 
221 	boolean_t		ds_lowlink;		/* SL */
222 	boolean_t		ds_nonip;		/* SL */
223 };
224 
225 
226 #define	DLD_DATATHR_INC(dsp)	{		\
227 	ASSERT(MUTEX_HELD(&(dsp)->ds_lock));	\
228 	dsp->ds_datathr_cnt++;			\
229 }
230 
231 #define	DLD_DATATHR_DCR(dsp)	{		\
232 	mutex_enter(&(dsp)->ds_lock);		\
233 	(dsp)->ds_datathr_cnt--;		\
234 	if ((dsp)->ds_datathr_cnt == 0)		\
235 		cv_broadcast(&(dsp)->ds_datathr_cv);	\
236 	mutex_exit(&(dsp)->ds_lock);		\
237 }
238 
239 /*
240  * dld_str.c module.
241  */
242 
243 extern void		dld_str_init(void);
244 extern int		dld_str_fini(void);
245 extern dld_str_t	*dld_str_create(queue_t *, uint_t, major_t,
246     t_uscalar_t);
247 extern void		dld_str_destroy(dld_str_t *);
248 extern int		dld_str_attach(dld_str_t *, t_uscalar_t);
249 extern void		dld_str_detach(dld_str_t *);
250 extern void		dld_str_rx_raw(void *, mac_resource_handle_t,
251     mblk_t *, mac_header_info_t *);
252 extern void		dld_str_rx_fastpath(void *, mac_resource_handle_t,
253     mblk_t *, mac_header_info_t *);
254 extern void		dld_str_rx_unitdata(void *, mac_resource_handle_t,
255     mblk_t *, mac_header_info_t *);
256 extern void		dld_str_notify_ind(dld_str_t *);
257 extern mac_tx_cookie_t	str_mdata_fastpath_put(dld_str_t *, mblk_t *,
258     uintptr_t, uint16_t);
259 extern int		dld_flow_ctl_callb(dld_str_t *, uint64_t,
260     int (*func)(), void *);
261 
262 /*
263  * dld_proto.c
264  */
265 extern void		dld_proto(dld_str_t *, mblk_t *);
266 extern void		dld_proto_unitdata_req(dld_str_t *, mblk_t *);
267 extern void		dld_capabilities_disable(dld_str_t *);
268 extern void		proto_unitdata_req(dld_str_t *, mblk_t *);
269 
270 /*
271  * dld_flow.c
272  */
273 extern void		flow_rx_pkt_chain(void *, void *, mblk_t *);
274 
275 /*
276  * dld_drv.c
277  */
278 extern mac_handle_t	dld_mac_open(char *dev_name, int *err);
279 #define	dld_mac_close(mh) mac_close(mh)
280 
281 /*
282  * Options: there should be a separate bit defined here for each
283  *          DLD_PROP... defined in dld.h.
284  */
285 #define	DLD_OPT_NO_FASTPATH	0x00000001
286 #define	DLD_OPT_NO_POLL		0x00000002
287 #define	DLD_OPT_NO_ZEROCOPY	0x00000004
288 #define	DLD_OPT_NO_SOFTRING	0x00000008
289 
290 extern uint32_t		dld_opt;
291 
292 /*
293  * autopush information
294  */
295 typedef struct dld_ap {
296 	datalink_id_t		da_linkid;
297 	struct dlautopush	da_ap;
298 
299 #define	da_anchor		da_ap.dap_anchor
300 #define	da_npush		da_ap.dap_npush
301 #define	da_aplist		da_ap.dap_aplist
302 
303 } dld_ap_t;
304 
305 /*
306  * Useful macros.
307  */
308 
309 #define	DLD_SETQFULL(dsp) {						\
310 	queue_t *q = (dsp)->ds_wq;					\
311 									\
312 	mutex_enter(&(dsp)->ds_lock);					\
313 	if ((dsp)->ds_tx_flow_mp != NULL) {				\
314 		(void) putq(q, (dsp)->ds_tx_flow_mp);			\
315 		(dsp)->ds_tx_flow_mp = NULL;				\
316 		qenable((dsp)->ds_wq);					\
317 	}								\
318 	mutex_exit(&(dsp)->ds_lock);					\
319 }
320 
321 /*
322  * This is called to check whether we can disable the flow control, and
323  * it is usually only needed in TX data-path when the dsp->ds_dlstate is
324  * DL_IDLE. Otherwise, it does not hurt to always disable the flow control.
325  */
326 #define	DLD_CLRQFULL(dsp) {					\
327 	queue_t *q = (dsp)->ds_wq;				\
328 								\
329 	mutex_enter(&(dsp)->ds_lock);				\
330 	if ((dsp)->ds_dlstate != DL_IDLE ||			\
331 	    !mac_tx_is_flow_blocked((dsp)->ds_mch, 0)) {	\
332 		if ((dsp)->ds_tx_flow_mp == NULL)		\
333 			(dsp)->ds_tx_flow_mp = getq(q);		\
334 		ASSERT((dsp)->ds_tx_flow_mp != NULL);		\
335 	}							\
336 	mutex_exit(&(dsp)->ds_lock);				\
337 }
338 
339 #define	DLD_TX(dsp, mp, f_hint, flag)				\
340 	mac_tx(dsp->ds_mch, mp, f_hint, flag, NULL)
341 
342 #ifdef DEBUG
343 #define	DLD_DBG		cmn_err
344 #else
345 #define	DLD_DBG		if (0) cmn_err
346 #endif
347 
348 #ifdef	__cplusplus
349 }
350 #endif
351 
352 #endif	/* _SYS_DLD_IMPL_H */
353