C++ InterlockedExchangePointer函数代码示例

static int
telos_alloc_bufs(struct telos_ap *telos, int mtu)
{
	int err = -1;
	unsigned long len;
	char * rbuff = NULL;
	char * xbuff = NULL;

	/*
	 * Allocate the TELOS_AP frame buffers:
	 *
	 * rbuff	Receive buffer.
	 * xbuff	Transmit buffer.
	 * cbuff        Temporary compression buffer.
	 */
	len = mtu * 2;

	/*
	 * allow for arrival of larger UDP packets, even if we say not to
	 * also fixes a bug in which SunOS sends 512-byte packets even with
	 * an MSS of 128
	 */
	if (len < 576 * 2)
		len = 576 * 2;

	rbuff = (char *) malloc(len + 4);
	if (rbuff == NULL)
		goto err_exit;
	xbuff = (char *) malloc(len + 4);
	if (xbuff == NULL)
		goto err_exit;
/*
	spin_lock_bh(&telos->lock);
	if (telos->tty == NULL) {
		spin_unlock_bh(&telos->lock);
		err = -ENODEV;
		goto err_exit;
	}
*/
	telos->mtu	    = mtu;
	telos->buffsize = len;
	telos->rcount   = 0;
	telos->xleft    = 0;
	rbuff = (char*) InterlockedExchangePointer(&telos->rbuff, rbuff);
	xbuff = (char*) InterlockedExchangePointer(&telos->xbuff, xbuff);
//	spin_unlock_bh(&telos->lock);
	err = 0;

	/* Cleanup */
err_exit:
	if (xbuff)
		free(xbuff);
	if (rbuff)
		free(rbuff);
	return err;
}

/***************************************************************************
 *                              MCIQTZ_notifyThread             [internal]
 */
static DWORD CALLBACK MCIQTZ_notifyThread(LPVOID parm)
{
    WINE_MCIQTZ* wma = (WINE_MCIQTZ *)parm;
    HRESULT hr;
    HANDLE handle[2];
    DWORD n = 0, ret = 0;

    handle[n++] = wma->stop_event;
    IMediaEvent_GetEventHandle(wma->mevent, (OAEVENT *)&handle[n++]);

    for (;;) {
        DWORD r;
        HANDLE old;

        r = WaitForMultipleObjects(n, handle, FALSE, INFINITE);
        if (r == WAIT_OBJECT_0) {
            TRACE("got stop event\n");
            old = InterlockedExchangePointer(&wma->callback, NULL);
            if (old)
                mciDriverNotify(old, wma->notify_devid, MCI_NOTIFY_ABORTED);
            break;
        }
        else if (r == WAIT_OBJECT_0+1) {
            LONG event_code;
            LONG_PTR p1, p2;
            do {
                hr = IMediaEvent_GetEvent(wma->mevent, &event_code, &p1, &p2, 0);
                if (SUCCEEDED(hr)) {
                    TRACE("got event_code = 0x%02x\n", event_code);
                    IMediaEvent_FreeEventParams(wma->mevent, event_code, p1, p2);
                }
            } while (hr == S_OK && event_code != EC_COMPLETE);
            if (hr == S_OK && event_code == EC_COMPLETE) {
                old = InterlockedExchangePointer(&wma->callback, NULL);
                if (old)
                    mciDriverNotify(old, wma->notify_devid, MCI_NOTIFY_SUCCESSFUL);
                break;
            }
        }
        else {
            TRACE("Unknown error (%d)\n", (int)r);
            break;
        }
    }

    hr = IMediaControl_Stop(wma->pmctrl);
    if (FAILED(hr)) {
        TRACE("Cannot stop filtergraph (hr = %x)\n", hr);
        ret = MCIERR_INTERNAL;
    }

    return ret;
}

BOOL CKTrojanUIHandler::InitKTrojan(BOOL bPreLoad /* = FALSE */)
{
	BOOL retval = FALSE;
	CreateKTrojanObject_t CreateKTrojanObject = NULL;
	TCHAR szKTrojanPath[MAX_PATH] = { 0 };
	HRESULT hr;
	HMODULE hKTrojan = NULL;
	IKTrojan* piKTrojan = NULL;
	HWND hWnd = NULL;

	if (!m_hKTrajon)
	{
		::GetModuleFileName(NULL, szKTrojanPath, MAX_PATH);
		PathRemoveFileSpec(szKTrojanPath);
		PathAppend(szKTrojanPath, _T("kscan.dll"));
		hKTrojan = LoadLibrary(szKTrojanPath);
		if (!hKTrojan)
			goto clean0;

		InterlockedExchangePointer((void**)&m_hKTrajon, hKTrojan);
	}

	if (!m_piKTrajon)
	{
		CreateKTrojanObject = (CreateKTrojanObject_t)GetProcAddress(m_hKTrajon, "CreateKTrojanObject");
		if (!CreateKTrojanObject)
			goto clean0;

		hr = CreateKTrojanObject(__uuidof(IKTrojan), (void**)&piKTrojan);
		if (FAILED(hr))
			goto clean0;

		InterlockedExchangePointer((void**)&m_piKTrajon, piKTrojan);
	}
	if (!m_wndKTrojan.m_hWnd)
	{
		hWnd = m_piKTrajon->CreateKTrojan(m_dlg->GetViewHWND());
		InterlockedExchangePointer((void**)&m_wndKTrojan.m_hWnd, hWnd);
		m_piKTrajon->SetNotify(m_dlg);
		m_piKTrajon->Init();
	}

	retval = TRUE;

clean0:
	if (!retval)
	{
		UnInitKTrojan();
	}

	return retval;
}

/* Free a TELOS_AP channel buffers. */
static void
telos_free_bufs(struct telos_ap *telos)
{
	void * tmp;

	// printk(KERN_WARNING "%s: %p\n", __FUNCTION__, telos);

	/* Free all TELOS_AP frame buffers. */
	if ((tmp = InterlockedExchangePointer(&telos->rbuff, NULL)) != NULL)
		free(tmp);
	if ((tmp = InterlockedExchangePointer(&telos->xbuff, NULL)) != NULL)
		free(tmp);
}

// If the cache is not being used reset it
void Cache::ResetCache(IScriptEnvironment* env)
{
  InterlockedIncrement(&g_Cache_stats.resets);
  minframe = vi.num_frames;
  maxframe = -1;
  CachedVideoFrame *i, *j;

  _RPT3(0, "Cache:%x: Cache Reset, cache_limit %d, cache_init %d\n", this, cache_limit, cache_init<<CACHE_SCALE_SHIFT);

  int count=0;
  for (i = video_frames.next; i != &video_frames; i = i->next) {
    if (++count >= cache_init) goto purge_old_frame;

    const int ifn = i->frame_number;
    if (ifn < minframe) minframe = ifn;
    if (ifn > maxframe) maxframe = ifn;
  }
  return;

purge_old_frame:

  // Truncate the tail of the chain
  video_frames.prev = i;
  j = (CachedVideoFrame*)InterlockedExchangePointer(&i->next, &video_frames);

  // Delete the excess CachedVideoFrames
  while (j != &video_frames) {
    i = j->next;
    ReturnVideoFrameBuffer(j, env); // Return old vfb to vfb pool for early reuse
    delete j;
    j = i;
  }
  cache_limit = cache_init << CACHE_SCALE_SHIFT;
}

/***********************************************************************
 *           ToolHelpHook                             (KERNEL.341)
 *	see "Undocumented Windows"
 */
FARPROC16 WINAPI ToolHelpHook16(FARPROC16 func)
{
    static FARPROC16 hook;

    FIXME("(%p), stub.\n", func);
    return InterlockedExchangePointer( (void **)&hook, func );
}

void COptex::SetSpinCount(DWORD dwSpinCount) {

   // No spinning on single CPU machines
   if (!sm_fUniprocessorHost)
      InterlockedExchangePointer((PVOID*) &m_psi->m_dwSpinCount, 
        (PVOID) (DWORD_PTR) dwSpinCount);
}

void
mono_thread_info_uninstall_interrupt (gboolean *interrupted)
{
	MonoThreadInfo *info;
	MonoThreadInfoInterruptToken *previous_token;

	g_assert (interrupted);
	*interrupted = FALSE;

	info = mono_thread_info_current ();
	g_assert (info);

	previous_token = (MonoThreadInfoInterruptToken *)InterlockedExchangePointer ((gpointer*) &info->interrupt_token, NULL);

	/* only the installer can uninstall the token */
	g_assert (previous_token);

	if (previous_token == INTERRUPT_STATE) {
		/* if it is interrupted, then it is going to be freed in finish interrupt */
		*interrupted = TRUE;
	} else {
		g_free (previous_token);
	}

	THREADS_INTERRUPT_DEBUG ("interrupt uninstall  tid %p previous_token %p interrupted %s\n",
		mono_thread_info_get_tid (info), previous_token, *interrupted ? "TRUE" : "FALSE");
}

/**************************************************************************
 *				MCICDA_mciNotify		[internal]
 *
 * Notifications in MCI work like a 1-element queue.
 * Each new notification request supersedes the previous one.
 */
static void MCICDA_Notify(DWORD_PTR hWndCallBack, WINE_MCICDAUDIO* wmcda, UINT wStatus)
{
    MCIDEVICEID wDevID = wmcda->wNotifyDeviceID;
    HANDLE old = InterlockedExchangePointer(&wmcda->hCallback, NULL);
    if (old) mciDriverNotify(old, wDevID, MCI_NOTIFY_SUPERSEDED);
    mciDriverNotify(HWND_32(LOWORD(hWndCallBack)), wDevID, wStatus);
}

/**************************************************************************
 * 				MCICDA_Stop			[internal]
 */
static DWORD MCICDA_Stop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
{
    WINE_MCICDAUDIO*	wmcda = MCICDA_GetOpenDrv(wDevID);
    HANDLE		oldcb;
    DWORD               br;

    TRACE("(%04X, %08X, %p);\n", wDevID, dwFlags, lpParms);

    if (wmcda == NULL)	return MCIERR_INVALID_DEVICE_ID;

    oldcb = InterlockedExchangePointer(&wmcda->hCallback, NULL);
    if (oldcb) mciDriverNotify(oldcb, wmcda->wNotifyDeviceID, MCI_NOTIFY_ABORTED);

    if (wmcda->hThread != 0) {
        SetEvent(wmcda->stopEvent);
        WaitForSingleObject(wmcda->hThread, INFINITE);

        CloseHandle(wmcda->hThread);
        wmcda->hThread = 0;
        CloseHandle(wmcda->stopEvent);
        wmcda->stopEvent = 0;

        IDirectSoundBuffer_Release(wmcda->dsBuf);
        wmcda->dsBuf = NULL;
        IDirectSound_Release(wmcda->dsObj);
        wmcda->dsObj = NULL;
    }
    else if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_STOP_AUDIO, NULL, 0, NULL, 0, &br, NULL))
        return MCIERR_HARDWARE;

    if ((dwFlags & MCI_NOTIFY) && lpParms)
	MCICDA_Notify(lpParms->dwCallback, wmcda, MCI_NOTIFY_SUCCESSFUL);
    return 0;
}

static VOID _HookFastIoRoutine(PVOID *DriverRoutine, PVOID *RecordRoutine, PVOID HookRoutine)
{
	if (*DriverRoutine != NULL) 
		*RecordRoutine = InterlockedExchangePointer(DriverRoutine, HookRoutine);

	return;
}

/**************************************************************************
 *                              MCIQTZ_mciNotify                [internal]
 *
 * Notifications in MCI work like a 1-element queue.
 * Each new notification request supersedes the previous one.
 */
static void MCIQTZ_mciNotify(DWORD_PTR hWndCallBack, WINE_MCIQTZ* wma, UINT wStatus)
{
    MCIDEVICEID wDevID = wma->notify_devid;
    HANDLE old = InterlockedExchangePointer(&wma->callback, NULL);
    if (old) mciDriverNotify(old, wDevID, MCI_NOTIFY_SUPERSEDED);
    mciDriverNotify(HWND_32(LOWORD(hWndCallBack)), wDevID, wStatus);
}

HGLOBAL MGlobal::Alloc(UINT nFlags, size_t cbSize)
{
	Free(); // JIC

	InterlockedExchangePointer((PVOID*)&mh_Global, GlobalAlloc(nFlags, cbSize));
	return mh_Global;
}

BOOL CBackgroundUpdater::Start()
{
    BuDebugMessage("CBackgroundUpdater::Start() BEGIN");

	if (m_hThread!=NULL)
	{
		BuDebugMessage("CBackgroundUpdater::Start() ALREADY STARTED");
		return FALSE;
	}

	DWORD dwThreadID;
	HANDLE hThread=CreateThread(NULL,0,UpdaterThreadProc,this,CREATE_SUSPENDED,&dwThreadID);
	DebugOpenHandle(dhtThread,hThread,"BackgroundUpdater");
	DebugFormatMessage("BU started, thread ID=%X",dwThreadID);


	if (hThread==NULL)
		return FALSE;

	InterlockedExchangePointer(&m_hThread,hThread);
	SetThreadPriority(m_hThread,THREAD_PRIORITY_BELOW_NORMAL);
	
	InterlockedExchange(&m_lIsWaiting,FALSE);
	ResumeThread(m_hThread);

	BuDebugMessage("CBackgroundUpdater::Start() END");
	return TRUE;
}

void* VInterlocked::ExchangeVoidPtr(void** inValue, void* inNewValue)
{
#if VERSIONWIN

	#pragma warning (push)
	#pragma warning (disable: 4311)
	#pragma warning (disable: 4312)

	void* val = InterlockedExchangePointer( inValue, inNewValue);
//	void* val = (void*) ::InterlockedExchange((long*) inValue, (long)inNewValue);

	#pragma warning (pop)

#elif VERSIONMAC

	void* val;
	do {
		val = *inValue;
		// one must loop if a swap occured between reading the old val and a failed CAS
		// because if we return the old val, the caller may assume that the CAS has succeeded.
	} while(!::OSAtomicCompareAndSwapPtrBarrier( val, inNewValue, inValue));

#elif VERSION_LINUX

    void* val=__sync_lock_test_and_set(inValue, inNewValue);

#endif
	return val;
}