timer-r0drv-solaris.c@ 44579

Last change on this file since 44579 was 44528, checked in by vboxsync, 12 years ago
header (C) fixes
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 12.7 KB

Line
1	/* $Id: timer-r0drv-solaris.c 44528 2013-02-04 14:27:54Z vboxsync $ */
2	/** @file
3	* IPRT - Timer, Ring-0 Driver, Solaris.
4	*/
5
6	/*
7	* Copyright (C) 2006-2012 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	/*******************************************************************************
29	* Header Files *
30	*******************************************************************************/
31	#include "the-solaris-kernel.h"
32	#include "internal/iprt.h"
33	#include <iprt/timer.h>
34
35	#include <iprt/asm.h>
36	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)
37	# include <iprt/asm-amd64-x86.h>
38	#endif
39	#include <iprt/assert.h>
40	#include <iprt/err.h>
41	#include <iprt/mem.h>
42	#include <iprt/mp.h>
43	#include <iprt/spinlock.h>
44	#include <iprt/time.h>
45	#include <iprt/thread.h>
46	#include "internal/magics.h"
47
48	#define SOL_TIMER_ANY_CPU (-1)
49
50	/*******************************************************************************
51	* Structures and Typedefs *
52	*******************************************************************************/
53	/**
54	* Single-CPU timer handle.
55	*/
56	typedef struct RTR0SINGLETIMERSOL
57	{
58	/** Cyclic handler. */
59	cyc_handler_t hHandler;
60	/** Cyclic time and interval representation. */
61	cyc_time_t hFireTime;
62	/** Timer ticks. */
63	uint64_t u64Tick;
64	} RTR0SINGLETIMERSOL;
65	typedef RTR0SINGLETIMERSOL *PRTR0SINGLETIMERSOL;
66
67	/**
68	* Omni-CPU timer handle.
69	*/
70	typedef struct RTR0OMNITIMERSOL
71	{
72	/** Absolute timestamp of when the timer should fire next. */
73	uint64_t u64When;
74	/** Array of timer ticks per CPU. Reinitialized when a CPU is online'd. */
75	uint64_t *au64Ticks;
76	} RTR0OMNITIMERSOL;
77	typedef RTR0OMNITIMERSOL *PRTR0OMNITIMERSOL;
78
79	/**
80	* The internal representation of a Solaris timer handle.
81	*/
82	typedef struct RTTIMER
83	{
84	/** Magic.
85	* This is RTTIMER_MAGIC, but changes to something else before the timer
86	* is destroyed to indicate clearly that thread should exit. */
87	uint32_t volatile u32Magic;
88	/** Flag indicating that the timer is suspended. */
89	uint8_t volatile fSuspended;
90	/** Whether the timer must run on all CPUs or not. */
91	uint8_t fAllCpu;
92	/** Whether the timer must run on a specific CPU or not. */
93	uint8_t fSpecificCpu;
94	/** The CPU it must run on if fSpecificCpu is set. */
95	uint8_t iCpu;
96	/** The nano second interval for repeating timers. */
97	uint64_t interval;
98	/** Cyclic timer Id. */
99	cyclic_id_t hCyclicId;
100	/** @todo Make this a union unless we intend to support omni<=>single timers
101	* conversions. */
102	/** Single-CPU timer handle. */
103	PRTR0SINGLETIMERSOL pSingleTimer;
104	/** Omni-CPU timer handle. */
105	PRTR0OMNITIMERSOL pOmniTimer;
106	/** The user callback. */
107	PFNRTTIMER pfnTimer;
108	/** The argument for the user callback. */
109	void *pvUser;
110	} RTTIMER;
111
112
113	/*******************************************************************************
114	* Defined Constants And Macros *
115	*******************************************************************************/
116	/** Validates that the timer is valid. */
117	#define RTTIMER_ASSERT_VALID_RET(pTimer) \
118	do \
119	{ \
120	AssertPtrReturn(pTimer, VERR_INVALID_HANDLE); \
121	AssertMsgReturn((pTimer)->u32Magic == RTTIMER_MAGIC, ("pTimer=%p u32Magic=%x expected %x\n", (pTimer), (pTimer)->u32Magic, RTTIMER_MAGIC), \
122	VERR_INVALID_HANDLE); \
123	} while (0)
124
125
126	/**
127	* Callback wrapper for Omni-CPU and single-CPU timers.
128	*
129	* @param pvArg Opaque pointer to the timer.
130	*
131	* @remarks This will be executed in interrupt context but only at the specified
132	* level i.e. CY_LOCK_LEVEL in our case. We -CANNOT- call into the
133	* cyclic subsystem here, neither should pfnTimer().
134	*/
135	static void rtTimerSolCallbackWrapper(void *pvArg)
136	{
137	PRTTIMER pTimer = (PRTTIMER)pvArg;
138	AssertPtrReturnVoid(pTimer);
139
140	if (pTimer->pSingleTimer)
141	{
142	uint64_t u64Tick = ++pTimer->pSingleTimer->u64Tick;
143	pTimer->pfnTimer(pTimer, pTimer->pvUser, u64Tick);
144	}
145	else if (pTimer->pOmniTimer)
146	{
147	uint64_t u64Tick = ++pTimer->pOmniTimer->au64Ticks[CPU->cpu_id];
148	pTimer->pfnTimer(pTimer, pTimer->pvUser, u64Tick);
149	}
150	}
151
152
153	/**
154	* Omni-CPU cyclic online event. This is called before the omni cycle begins to
155	* fire on the specified CPU.
156	*
157	* @param pvArg Opaque pointer to the timer.
158	* @param pCpu Pointer to the CPU on which it will fire.
159	* @param pCyclicHandler Pointer to a cyclic handler to add to the CPU
160	* specified in @a pCpu.
161	* @param pCyclicTime Pointer to the cyclic time and interval object.
162	*
163	* @remarks We -CANNOT- call back into the cyclic subsystem here, we can however
164	* block (sleep).
165	*/
166	static void rtTimerSolOmniCpuOnline(void pvArg, cpu_t pCpu, cyc_handler_t pCyclicHandler, cyc_time_t pCyclicTime)
167	{
168	PRTTIMER pTimer = (PRTTIMER)pvArg;
169	AssertPtrReturnVoid(pTimer);
170	AssertPtrReturnVoid(pCpu);
171	AssertPtrReturnVoid(pCyclicHandler);
172	AssertPtrReturnVoid(pCyclicTime);
173
174	pTimer->pOmniTimer->au64Ticks[pCpu->cpu_id] = 0;
175	pCyclicHandler->cyh_func = rtTimerSolCallbackWrapper;
176	pCyclicHandler->cyh_arg = pTimer;
177	pCyclicHandler->cyh_level = CY_LOCK_LEVEL;
178
179	uint64_t u64Now = RTTimeNanoTS();
180	if (pTimer->pOmniTimer->u64When < u64Now)
181	pCyclicTime->cyt_when = u64Now + pTimer->interval / 2;
182	else
183	pCyclicTime->cyt_when = pTimer->pOmniTimer->u64When;
184
185	pCyclicTime->cyt_interval = pTimer->interval;
186	}
187
188
189	RTDECL(int) RTTimerCreateEx(PRTTIMER ppTimer, uint64_t u64NanoInterval, uint32_t fFlags, PFNRTTIMER pfnTimer, void pvUser)
190	{
191	RT_ASSERT_PREEMPTIBLE();
192	*ppTimer = NULL;
193
194	/*
195	* Validate flags.
196	*/
197	if (!RTTIMER_FLAGS_ARE_VALID(fFlags))
198	return VERR_INVALID_PARAMETER;
199
200	if ( (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC)
201	&& (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL
202	&& !RTMpIsCpuPossible(RTMpCpuIdFromSetIndex(fFlags & RTTIMER_FLAGS_CPU_MASK)))
203	return VERR_CPU_NOT_FOUND;
204
205	if ((fFlags & RTTIMER_FLAGS_CPU_ALL) == RTTIMER_FLAGS_CPU_ALL && u64NanoInterval == 0)
206	return VERR_NOT_SUPPORTED;
207
208	/*
209	* Allocate and initialize the timer handle.
210	*/
211	PRTTIMER pTimer = (PRTTIMER)RTMemAlloc(sizeof(*pTimer));
212	if (!pTimer)
213	return VERR_NO_MEMORY;
214
215	pTimer->u32Magic = RTTIMER_MAGIC;
216	pTimer->fSuspended = true;
217	if ((fFlags & RTTIMER_FLAGS_CPU_ALL) == RTTIMER_FLAGS_CPU_ALL)
218	{
219	pTimer->fAllCpu = true;
220	pTimer->fSpecificCpu = false;
221	pTimer->iCpu = 255;
222	}
223	else if (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC)
224	{
225	pTimer->fAllCpu = false;
226	pTimer->fSpecificCpu = true;
227	pTimer->iCpu = fFlags & RTTIMER_FLAGS_CPU_MASK; /* ASSUMES: index == cpuid */
228	}
229	else
230	{
231	pTimer->fAllCpu = false;
232	pTimer->fSpecificCpu = false;
233	pTimer->iCpu = 255;
234	}
235	pTimer->interval = u64NanoInterval;
236	pTimer->pfnTimer = pfnTimer;
237	pTimer->pvUser = pvUser;
238	pTimer->pSingleTimer = NULL;
239	pTimer->pOmniTimer = NULL;
240	pTimer->hCyclicId = CYCLIC_NONE;
241
242	*ppTimer = pTimer;
243	return VINF_SUCCESS;
244	}
245
246
247	RTDECL(int) RTTimerDestroy(PRTTIMER pTimer)
248	{
249	if (pTimer == NULL)
250	return VINF_SUCCESS;
251	RTTIMER_ASSERT_VALID_RET(pTimer);
252	RT_ASSERT_INTS_ON();
253
254	/*
255	* Free the associated resources.
256	*/
257	RTTimerStop(pTimer);
258	ASMAtomicWriteU32(&pTimer->u32Magic, ~RTTIMER_MAGIC);
259	RTMemFree(pTimer);
260	return VINF_SUCCESS;
261	}
262
263
264	RTDECL(int) RTTimerStart(PRTTIMER pTimer, uint64_t u64First)
265	{
266	RTTIMER_ASSERT_VALID_RET(pTimer);
267	RT_ASSERT_INTS_ON();
268
269	if (!pTimer->fSuspended)
270	return VERR_TIMER_ACTIVE;
271
272	/* One-shot timers are not supported by the cyclic system. */
273	if (pTimer->interval == 0)
274	return VERR_NOT_SUPPORTED;
275
276	pTimer->fSuspended = false;
277	if (pTimer->fAllCpu)
278	{
279	PRTR0OMNITIMERSOL pOmniTimer = RTMemAllocZ(sizeof(RTR0OMNITIMERSOL));
280	if (RT_UNLIKELY(!pOmniTimer))
281	return VERR_NO_MEMORY;
282
283	pOmniTimer->au64Ticks = RTMemAllocZ(RTMpGetCount() * sizeof(uint64_t));
284	if (RT_UNLIKELY(!pOmniTimer->au64Ticks))
285	{
286	RTMemFree(pOmniTimer);
287	return VERR_NO_MEMORY;
288	}
289
290	/*
291	* Setup omni (all CPU) timer. The Omni-CPU online event will fire
292	* and from there we setup periodic timers per CPU.
293	*/
294	pTimer->pOmniTimer = pOmniTimer;
295	pOmniTimer->u64When = pTimer->interval + RTTimeNanoTS();
296
297	cyc_omni_handler_t hOmni;
298	hOmni.cyo_online = rtTimerSolOmniCpuOnline;
299	hOmni.cyo_offline = NULL;
300	hOmni.cyo_arg = pTimer;
301
302	mutex_enter(&cpu_lock);
303	pTimer->hCyclicId = cyclic_add_omni(&hOmni);
304	mutex_exit(&cpu_lock);
305	}
306	else
307	{
308	int iCpu = SOL_TIMER_ANY_CPU;
309	if (pTimer->fSpecificCpu)
310	{
311	iCpu = pTimer->iCpu;
312	if (!RTMpIsCpuOnline(iCpu)) /* ASSUMES: index == cpuid */
313	return VERR_CPU_OFFLINE;
314	}
315
316	PRTR0SINGLETIMERSOL pSingleTimer = RTMemAllocZ(sizeof(RTR0SINGLETIMERSOL));
317	if (RT_UNLIKELY(!pSingleTimer))
318	return VERR_NO_MEMORY;
319
320	pTimer->pSingleTimer = pSingleTimer;
321	pSingleTimer->hHandler.cyh_func = rtTimerSolCallbackWrapper;
322	pSingleTimer->hHandler.cyh_arg = pTimer;
323	pSingleTimer->hHandler.cyh_level = CY_LOCK_LEVEL;
324
325	mutex_enter(&cpu_lock);
326	if (iCpu != SOL_TIMER_ANY_CPU && !cpu_is_online(cpu[iCpu]))
327	{
328	mutex_exit(&cpu_lock);
329	RTMemFree(pSingleTimer);
330	pTimer->pSingleTimer = NULL;
331	return VERR_CPU_OFFLINE;
332	}
333
334	pSingleTimer->hFireTime.cyt_when = u64First + RTTimeNanoTS();
335	if (pTimer->interval == 0)
336	{
337	/** @todo use gethrtime_max instead of LLONG_MAX? */
338	AssertCompileSize(pSingleTimer->hFireTime.cyt_interval, sizeof(long long));
339	pSingleTimer->hFireTime.cyt_interval = LLONG_MAX - pSingleTimer->hFireTime.cyt_when;
340	}
341	else
342	pSingleTimer->hFireTime.cyt_interval = pTimer->interval;
343
344	pTimer->hCyclicId = cyclic_add(&pSingleTimer->hHandler, &pSingleTimer->hFireTime);
345	if (iCpu != SOL_TIMER_ANY_CPU)
346	cyclic_bind(pTimer->hCyclicId, cpu[iCpu], NULL /* cpupart */);
347
348	mutex_exit(&cpu_lock);
349	}
350
351	return VINF_SUCCESS;
352	}
353
354
355	RTDECL(int) RTTimerStop(PRTTIMER pTimer)
356	{
357	RTTIMER_ASSERT_VALID_RET(pTimer);
358	RT_ASSERT_INTS_ON();
359
360	if (pTimer->fSuspended)
361	return VERR_TIMER_SUSPENDED;
362
363	pTimer->fSuspended = true;
364	if (pTimer->pSingleTimer)
365	{
366	mutex_enter(&cpu_lock);
367	cyclic_remove(pTimer->hCyclicId);
368	mutex_exit(&cpu_lock);
369	RTMemFree(pTimer->pSingleTimer);
370	}
371	else if (pTimer->pOmniTimer)
372	{
373	mutex_enter(&cpu_lock);
374	cyclic_remove(pTimer->hCyclicId);
375	mutex_exit(&cpu_lock);
376	RTMemFree(pTimer->pOmniTimer->au64Ticks);
377	RTMemFree(pTimer->pOmniTimer);
378	}
379
380	return VINF_SUCCESS;
381	}
382
383
384	RTDECL(int) RTTimerChangeInterval(PRTTIMER pTimer, uint64_t u64NanoInterval)
385	{
386	RTTIMER_ASSERT_VALID_RET(pTimer);
387
388	/** @todo implement me! */
389
390	return VERR_NOT_SUPPORTED;
391	}
392
393
394	RTDECL(uint32_t) RTTimerGetSystemGranularity(void)
395	{
396	return nsec_per_tick;
397	}
398
399
400	RTDECL(int) RTTimerRequestSystemGranularity(uint32_t u32Request, uint32_t *pu32Granted)
401	{
402	return VERR_NOT_SUPPORTED;
403	}
404
405
406	RTDECL(int) RTTimerReleaseSystemGranularity(uint32_t u32Granted)
407	{
408	return VERR_NOT_SUPPORTED;
409	}
410
411
412	RTDECL(bool) RTTimerCanDoHighResolution(void)
413	{
414	/** @todo return true; - when missing bits have been implemented and tested*/
415	return false;
416	}
417

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

source: vbox/trunk/src/VBox/Runtime/r0drv/solaris/timer-r0drv-solaris.c@ 44579

Download in other formats: