VBoxNetAdp-solaris.c@ 57181

Last change on this file since 57181 was 56293, checked in by vboxsync, 10 years ago
HostDrivers: Updated (C) year.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 19.8 KB

Line
1	/* $Id: VBoxNetAdp-solaris.c 56293 2015-06-09 14:23:56Z vboxsync $ */
2	/** @file
3	* VBoxNetAdapter - Network Adapter Driver (Host), Solaris Specific Code.
4	*/
5
6	/*
7	* Copyright (C) 2009-2015 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27	/*******************************************************************************
28	* Header Files *
29	*******************************************************************************/
30	#define LOG_GROUP LOG_GROUP_NET_ADP_DRV
31	#include <VBox/log.h>
32	#include <VBox/err.h>
33	#include <VBox/version.h>
34	#include <iprt/assert.h>
35	#include <iprt/semaphore.h>
36	#include <iprt/initterm.h>
37	#include <iprt/assert.h>
38	#include <iprt/mem.h>
39	#include <iprt/rand.h>
40
41	#include <sys/types.h>
42	#include <sys/dlpi.h>
43	#include <sys/types.h>
44	#include <sys/param.h>
45	#include <sys/stat.h>
46	#include <sys/stream.h>
47	#include <sys/stropts.h>
48	#include <sys/strsun.h>
49	#include <sys/modctl.h>
50	#include <sys/ddi.h>
51	#include <sys/sunddi.h>
52	#include <sys/sunldi.h>
53	#include <sys/gld.h>
54
55	#include "../VBoxNetAdpInternal.h"
56
57	/*******************************************************************************
58	* Defined Constants And Macros *
59	*******************************************************************************/
60	#define DEVICE_NAME "vboxnet"
61	/** The module descriptions as seen in 'modinfo'. */
62	#define DEVICE_DESC_DRV "VirtualBox NetAdp"
63
64
65	/*******************************************************************************
66	* Internal Functions *
67	*******************************************************************************/
68	static int VBoxNetAdpSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd);
69	static int VBoxNetAdpSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd);
70	static int VBoxNetAdpSolarisQuiesceNotNeeded(dev_info_t *pDip);
71
72	/**
73	* Streams: module info.
74	*/
75	static struct module_info g_VBoxNetAdpSolarisModInfo =
76	{
77	0x0dd, /* module id */
78	DEVICE_NAME,
79	0, /* min. packet size */
80	INFPSZ, /* max. packet size */
81	0, /* hi-water mark */
82	0 /* lo-water mark */
83	};
84
85	/**
86	* Streams: read queue hooks.
87	*/
88	static struct qinit g_VBoxNetAdpSolarisReadQ =
89	{
90	NULL, /* read */
91	gld_rsrv,
92	gld_open,
93	gld_close,
94	NULL, /* admin (reserved) */
95	&g_VBoxNetAdpSolarisModInfo,
96	NULL /* module stats */
97	};
98
99	/**
100	* Streams: write queue hooks.
101	*/
102	static struct qinit g_VBoxNetAdpSolarisWriteQ =
103	{
104	gld_wput,
105	gld_wsrv,
106	NULL, /* open */
107	NULL, /* close */
108	NULL, /* admin (reserved) */
109	&g_VBoxNetAdpSolarisModInfo,
110	NULL /* module stats */
111	};
112
113	/**
114	* Streams: IO stream tab.
115	*/
116	static struct streamtab g_VBoxNetAdpSolarisStreamTab =
117	{
118	&g_VBoxNetAdpSolarisReadQ,
119	&g_VBoxNetAdpSolarisWriteQ,
120	NULL, /* muxread init */
121	NULL /* muxwrite init */
122	};
123
124	/**
125	* cb_ops: driver char/block entry points
126	*/
127	static struct cb_ops g_VBoxNetAdpSolarisCbOps =
128	{
129	nulldev, /* cb open */
130	nulldev, /* cb close */
131	nodev, /* b strategy */
132	nodev, /* b dump */
133	nodev, /* b print */
134	nodev, /* cb read */
135	nodev, /* cb write */
136	nodev, /* cb ioctl */
137	nodev, /* c devmap */
138	nodev, /* c mmap */
139	nodev, /* c segmap */
140	nochpoll, /* c poll */
141	ddi_prop_op, /* property ops */
142	&g_VBoxNetAdpSolarisStreamTab,
143	D_MP, /* compat. flag */
144	CB_REV /* revision */
145	};
146
147	/**
148	* dev_ops: driver entry/exit and other ops.
149	*/
150	static struct dev_ops g_VBoxNetAdpSolarisDevOps =
151	{
152	DEVO_REV, /* driver build revision */
153	0, /* ref count */
154	gld_getinfo,
155	nulldev, /* identify */
156	nulldev, /* probe */
157	VBoxNetAdpSolarisAttach,
158	VBoxNetAdpSolarisDetach,
159	nodev, /* reset */
160	&g_VBoxNetAdpSolarisCbOps,
161	(struct bus_ops *)0,
162	nodev, /* power */
163	VBoxNetAdpSolarisQuiesceNotNeeded
164	};
165
166	/**
167	* modldrv: export driver specifics to kernel
168	*/
169	static struct modldrv g_VBoxNetAdpSolarisDriver =
170	{
171	&mod_driverops, /* extern from kernel */
172	DEVICE_DESC_DRV " " VBOX_VERSION_STRING "r" RT_XSTR(VBOX_SVN_REV),
173	&g_VBoxNetAdpSolarisDevOps
174	};
175
176	/**
177	* modlinkage: export install/remove/info to the kernel
178	*/
179	static struct modlinkage g_VBoxNetAdpSolarisModLinkage =
180	{
181	MODREV_1, /* loadable module system revision */
182	{
183	&g_VBoxNetAdpSolarisDriver, /* adapter streams driver framework */
184	NULL /* terminate array of linkage structures */
185	}
186	};
187
188
189	/*******************************************************************************
190	* Global Variables *
191	*******************************************************************************/
192	/** The default ethernet broadcast address */
193	static uchar_t achBroadcastAddr[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
194
195	/**
196	* vboxnetadp_state_t: per-instance data
197	*/
198	typedef struct vboxnetadp_state_t
199	{
200	dev_info_t pDip; / device info. */
201	RTMAC FactoryMac; /* default 'factory' MAC address */
202	RTMAC CurrentMac; /* current MAC address */
203	} vboxnetadp_state_t;
204
205
206	/*******************************************************************************
207	* Internal Functions *
208	*******************************************************************************/
209	static int vboxNetAdpSolarisGenerateMac(PRTMAC pMac);
210	static int vboxNetAdpSolarisSetMacAddress(gld_mac_info_t pMacInfo, unsigned char pszMacAddr);
211	static int vboxNetAdpSolarisSend(gld_mac_info_t pMacInfo, mblk_t pMsg);
212	static int vboxNetAdpSolarisStub(gld_mac_info_t *pMacInfo);
213	static int vboxNetAdpSolarisSetPromisc(gld_mac_info_t *pMacInfo, int fPromisc);
214	static int vboxNetAdpSolarisSetMulticast(gld_mac_info_t pMacInfo, unsigned char pMulticastAddr, int fMulticast);
215	static int vboxNetAdpSolarisGetStats(gld_mac_info_t pMacInfo, struct gld_stats pStats);
216
217
218	/**
219	* Kernel entry points
220	*/
221	int _init(void)
222	{
223	LogFunc((DEVICE_NAME ":_init\n"));
224
225	/*
226	* Prevent module autounloading.
227	*/
228	modctl_t *pModCtl = mod_getctl(&g_VBoxNetAdpSolarisModLinkage);
229	if (pModCtl)
230	pModCtl->mod_loadflags \|= MOD_NOAUTOUNLOAD;
231	else
232	LogRel((DEVICE_NAME ":failed to disable autounloading!\n"));
233
234	/*
235	* Initialize IPRT.
236	*/
237	int rc = RTR0Init(0);
238	if (RT_SUCCESS(rc))
239	{
240	rc = mod_install(&g_VBoxNetAdpSolarisModLinkage);
241	if (!rc)
242	return rc;
243
244	LogRel((DEVICE_NAME ":mod_install failed. rc=%d\n", rc));
245	RTR0Term();
246	}
247	else
248	LogRel((DEVICE_NAME ":failed to initialize IPRT (rc=%d)\n", rc));
249
250	return RTErrConvertToErrno(rc);
251	}
252
253
254	int _fini(void)
255	{
256	LogFunc((DEVICE_NAME ":_fini\n"));
257
258	/*
259	* Undo the work done during start (in reverse order).
260	*/
261	RTR0Term();
262
263	return mod_remove(&g_VBoxNetAdpSolarisModLinkage);
264	}
265
266
267	int _info(struct modinfo *pModInfo)
268	{
269	LogFunc((DEVICE_NAME ":_info\n"));
270
271	int rc = mod_info(&g_VBoxNetAdpSolarisModLinkage, pModInfo);
272
273	Log((DEVICE_NAME ":_info returns %d\n", rc));
274	return rc;
275	}
276
277
278	/**
279	* Attach entry point, to attach a device to the system or resume it.
280	*
281	* @param pDip The module structure instance.
282	* @param enmCmd Operation type (attach/resume).
283	*
284	* @returns corresponding solaris error code.
285	*/
286	static int VBoxNetAdpSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
287	{
288	LogFunc((DEVICE_NAME ":VBoxNetAdpSolarisAttach pDip=%p enmCmd=%d\n", pDip, enmCmd));
289
290	int rc = -1;
291	switch (enmCmd)
292	{
293	case DDI_ATTACH:
294	{
295	gld_mac_info_t *pMacInfo = gld_mac_alloc(pDip);
296	if (pMacInfo)
297	{
298	vboxnetadp_state_t *pState = RTMemAllocZ(sizeof(vboxnetadp_state_t));
299	if (pState)
300	{
301	pState->pDip = pDip;
302
303	/*
304	* Setup GLD MAC layer registration info.
305	*/
306	pMacInfo->gldm_reset = vboxNetAdpSolarisStub;
307	pMacInfo->gldm_start = vboxNetAdpSolarisStub;
308	pMacInfo->gldm_stop = vboxNetAdpSolarisStub;
309	pMacInfo->gldm_set_mac_addr = vboxNetAdpSolarisSetMacAddress;
310	pMacInfo->gldm_set_multicast = vboxNetAdpSolarisSetMulticast;
311	pMacInfo->gldm_set_promiscuous = vboxNetAdpSolarisSetPromisc;
312	pMacInfo->gldm_send = vboxNetAdpSolarisSend;
313	pMacInfo->gldm_intr = NULL;
314	pMacInfo->gldm_get_stats = vboxNetAdpSolarisGetStats;
315	pMacInfo->gldm_ioctl = NULL;
316	pMacInfo->gldm_ident = DEVICE_NAME;
317	pMacInfo->gldm_type = DL_ETHER;
318	pMacInfo->gldm_minpkt = 0;
319	pMacInfo->gldm_maxpkt = VBOXNETADP_MTU;
320	pMacInfo->gldm_capabilities = GLD_CAP_LINKSTATE;
321	AssertCompile(sizeof(RTMAC) == ETHERADDRL);
322
323	pMacInfo->gldm_addrlen = ETHERADDRL;
324	pMacInfo->gldm_saplen = -2;
325	pMacInfo->gldm_broadcast_addr = achBroadcastAddr;
326	pMacInfo->gldm_ppa = ddi_get_instance(pState->pDip);
327	pMacInfo->gldm_devinfo = pState->pDip;
328	pMacInfo->gldm_private = (caddr_t)pState;
329
330	/*
331	* We use a semi-random MAC addresses similar to a guest NIC's MAC address
332	* as the default factory address of the interface.
333	*/
334	rc = vboxNetAdpSolarisGenerateMac(&pState->FactoryMac);
335	if (RT_SUCCESS(rc))
336	{
337	bcopy(&pState->FactoryMac, &pState->CurrentMac, sizeof(RTMAC));
338	pMacInfo->gldm_vendor_addr = (unsigned char *)&pState->FactoryMac;
339
340	/*
341	* Now try registering our GLD with the MAC layer.
342	* Registration can fail on some S10 versions when the MTU size is more than 1500.
343	* When we implement jumbo frames we should probably retry with MTU 1500 for S10.
344	*/
345	rc = gld_register(pDip, (char *)ddi_driver_name(pDip), pMacInfo);
346	if (rc == DDI_SUCCESS)
347	{
348	ddi_report_dev(pDip);
349	gld_linkstate(pMacInfo, GLD_LINKSTATE_UP);
350	return DDI_SUCCESS;
351	}
352	else
353	LogRel((DEVICE_NAME ":VBoxNetAdpSolarisAttach failed to register GLD. rc=%d\n", rc));
354	}
355	else
356	LogRel((DEVICE_NAME ":VBoxNetAdpSolarisAttach failed to generate mac address.rc=%d\n"));
357
358	RTMemFree(pState);
359	}
360	else
361	LogRel((DEVICE_NAME ":VBoxNetAdpSolarisAttach failed to alloc state.\n"));
362
363	gld_mac_free(pMacInfo);
364	}
365	else
366	LogRel((DEVICE_NAME ":VBoxNetAdpSolarisAttach failed to alloc mac structure.\n"));
367	return DDI_FAILURE;
368	}
369
370	case DDI_RESUME:
371	{
372	/* Nothing to do here... */
373	return DDI_SUCCESS;
374	}
375
376	/* case DDI_PM_RESUME: */
377	default:
378	return DDI_FAILURE;
379	}
380	}
381
382
383	/**
384	* Detach entry point, to detach a device to the system or suspend it.
385	*
386	* @param pDip The module structure instance.
387	* @param enmCmd Operation type (detach/suspend).
388	*
389	* @returns corresponding solaris error code.
390	*/
391	static int VBoxNetAdpSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
392	{
393	LogFunc((DEVICE_NAME ":VBoxNetAdpSolarisDetach pDip=%p enmCmd=%d\n", pDip, enmCmd));
394
395	switch (enmCmd)
396	{
397	case DDI_DETACH:
398	{
399	/*
400	* Unregister and clean up.
401	*/
402	gld_mac_info_t *pMacInfo = ddi_get_driver_private(pDip);
403	if (pMacInfo)
404	{
405	vboxnetadp_state_t pState = (vboxnetadp_state_t )pMacInfo->gldm_private;
406	if (pState)
407	{
408	gld_linkstate(pMacInfo, GLD_LINKSTATE_DOWN);
409	int rc = gld_unregister(pMacInfo);
410	if (rc == DDI_SUCCESS)
411	{
412	gld_mac_free(pMacInfo);
413	RTMemFree(pState);
414	return DDI_SUCCESS;
415	}
416	else
417	LogRel((DEVICE_NAME ":VBoxNetAdpSolarisDetach failed to unregister GLD from MAC layer.rc=%d\n", rc));
418	}
419	else
420	LogRel((DEVICE_NAME ":VBoxNetAdpSolarisDetach failed to get internal state.\n"));
421	}
422	else
423	LogRel((DEVICE_NAME ":VBoxNetAdpSolarisDetach failed to get driver private GLD data.\n"));
424
425	return DDI_FAILURE;
426	}
427
428	case DDI_RESUME:
429	{
430	/* Nothing to do here... */
431	return DDI_SUCCESS;
432	}
433
434	/* case DDI_SUSPEND: */
435	/* case DDI_HOTPLUG_DETACH: */
436	default:
437	return DDI_FAILURE;
438	}
439	}
440
441
442	/**
443	* Quiesce not-needed entry point, as Solaris 10 doesn't have any
444	* ddi_quiesce_not_needed() function.
445	*
446	* @param pDip The module structure instance.
447	*
448	* @return corresponding solaris error code.
449	*/
450	static int VBoxNetAdpSolarisQuiesceNotNeeded(dev_info_t *pDip)
451	{
452	return DDI_SUCCESS;
453	}
454
455
456	static int vboxNetAdpSolarisGenerateMac(PRTMAC pMac)
457	{
458	pMac->au8[0] = 0x08;
459	pMac->au8[1] = 0x00;
460	pMac->au8[2] = 0x27;
461	RTRandBytes(&pMac->au8[3], 3);
462	Log((DEVICE_NAME ":VBoxNetAdpSolarisGenerateMac Generated %.*Rhxs\n", sizeof(RTMAC), &pMac));
463	return VINF_SUCCESS;
464	}
465
466
467	static int vboxNetAdpSolarisSetMacAddress(gld_mac_info_t pMacInfo, unsigned char pszMacAddr)
468	{
469	vboxnetadp_state_t pState = (vboxnetadp_state_t )pMacInfo->gldm_private;
470	if (pState)
471	{
472	bcopy(pszMacAddr, &pState->CurrentMac, sizeof(RTMAC));
473	Log((DEVICE_NAME ":vboxNetAdpSolarisSetMacAddress updated MAC %.*Rhxs\n", sizeof(RTMAC), &pState->CurrentMac));
474	return GLD_SUCCESS;
475	}
476	else
477	LogRel((DEVICE_NAME ":vboxNetAdpSolarisSetMacAddress failed to get internal state.\n"));
478	return GLD_FAILURE;
479	}
480
481
482	static int vboxNetAdpSolarisSend(gld_mac_info_t pMacInfo, mblk_t pMsg)
483	{
484	while (pMsg)
485	{
486	mblk_t *pMsgNext = pMsg->b_cont;
487	pMsg->b_cont = NULL;
488	freemsg(pMsg);
489	pMsg = pMsgNext;
490	}
491	return GLD_SUCCESS;
492	}
493
494
495	static int vboxNetAdpSolarisStub(gld_mac_info_t *pMacInfo)
496	{
497	return GLD_SUCCESS;
498	}
499
500
501	static int vboxNetAdpSolarisSetMulticast(gld_mac_info_t pMacInfo, unsigned char pMulticastAddr, int fMulticast)
502	{
503	return GLD_SUCCESS;
504	}
505
506
507	static int vboxNetAdpSolarisSetPromisc(gld_mac_info_t *pMacInfo, int fPromisc)
508	{
509	/* Host requesting promiscuous intnet connection... */
510	return GLD_SUCCESS;
511	}
512
513
514	static int vboxNetAdpSolarisGetStats(gld_mac_info_t pMacInfo, struct gld_stats pStats)
515	{
516	/*
517	* For now fake up stats. Stats like duplex and speed are better set as they
518	* are used in utilities like dladm. Link state capabilities are critical
519	* as they are used by ipadm while trying to restore persistent interface configs.
520	*/
521	vboxnetadp_state_t pState = (vboxnetadp_state_t )pMacInfo->gldm_private;
522	if (pState)
523	{
524	pStats->glds_speed = 1000000000ULL; /* Bits/sec. */
525	pStats->glds_media = GLDM_UNKNOWN; /* Media/Connector Type */
526	pStats->glds_intr = 0; /* Interrupt count */
527	pStats->glds_norcvbuf = 0; /* Recv. discards */
528	pStats->glds_errxmt = 0; /* Xmit errors */
529	pStats->glds_errrcv = 0; /* Recv. errors */
530	pStats->glds_missed = 0; /* Pkt Drops on Recv. */
531	pStats->glds_underflow = 0; /* Buffer underflows */
532	pStats->glds_overflow = 0; /* Buffer overflows */
533
534	/* Ether */
535	pStats->glds_frame = 0; /* Align errors */
536	pStats->glds_crc = 0; /* CRC errors */
537	pStats->glds_duplex = GLD_DUPLEX_FULL; /* Link duplex state */
538	pStats->glds_nocarrier = 0; /* Carrier sense errors */
539	pStats->glds_collisions = 0; /* Xmit Collisions */
540	pStats->glds_excoll = 0; /* Frame discard due to excess collisions */
541	pStats->glds_xmtlatecoll = 0; /* Late collisions */
542	pStats->glds_defer = 0; /* Deferred Xmits */
543	pStats->glds_dot3_first_coll = 0; /* Single collision frames */
544	pStats->glds_dot3_multi_coll = 0; /* Multiple collision frames */
545	pStats->glds_dot3_sqe_error = 0; /* SQE errors */
546	pStats->glds_dot3_mac_xmt_error = 0; /* MAC Xmit errors */
547	pStats->glds_dot3_mac_rcv_error = 0; /* Mac Recv. errors */
548	pStats->glds_dot3_frame_too_long = 0; /* Frame too long errors */
549	pStats->glds_short = 0; /* Runt frames */
550
551	pStats->glds_noxmtbuf = 0; /* Xmit Buf errors */
552	pStats->glds_xmtretry = 0; /* Xmit retries */
553	pStats->glds_multixmt = 0; /* Multicast Xmits */
554	pStats->glds_multircv = 0; /* Multicast Recvs. */
555	pStats->glds_brdcstxmt = 0; /* Broadcast Xmits*/
556	pStats->glds_brdcstrcv = 0; /* Broadcast Recvs. */
557
558	return GLD_SUCCESS;
559	}
560	else
561	LogRel((DEVICE_NAME ":vboxNetAdpSolarisGetStats failed to get internal state.\n"));
562	return GLD_FAILURE;
563	}
564

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/HostDrivers/VBoxNetAdp/solaris/VBoxNetAdp-solaris.c@ 57181

Download in other formats: