NTSTATUS
SMBRetainServer(
SMBHANDLE inConnection)
{
OSAtomicIncrement32(&inConnection->refcount);
return STATUS_SUCCESS;
}
END_AS_NAMESPACE
#include <libkern/OSAtomic.h>
BEGIN_AS_NAMESPACE
asDWORD asCAtomic::atomicInc()
{
return OSAtomicIncrement32((int32_t*)&value);
}
END_AS_NAMESPACE
#include <libkern/OSAtomic.h>
BEGIN_AS_NAMESPACE
int asAtomicInc(int &value)
{
return OSAtomicIncrement32((int32_t*)&value);
}
void BufferManager::CopyAudioDataToFFTInputBuffer( Float32* inData, UInt32 numFrames )
{
UInt32 framesToCopy = min(numFrames, mFFTInputBufferLen - mFFTInputBufferFrameIndex);
memcpy(mFFTInputBuffer + mFFTInputBufferFrameIndex, inData, framesToCopy * sizeof(Float32));
mFFTInputBufferFrameIndex += framesToCopy * sizeof(Float32);
if (mFFTInputBufferFrameIndex >= mFFTInputBufferLen) {
OSAtomicIncrement32(&mHasNewFFTData);
OSAtomicDecrement32(&mNeedsNewFFTData);
}
}
unsigned
Atomic::operator++()
{
#if defined(_OPENTHREADS_ATOMIC_USE_GCC_BUILTINS)
return __sync_add_and_fetch(&_value, 1);
#elif defined(_OPENTHREADS_ATOMIC_USE_WIN32_INTERLOCKED)
return InterlockedIncrement(&_value);
#elif defined(_OPENTHREADS_ATOMIC_USE_BSD_ATOMIC)
return OSAtomicIncrement32(&_value);
#else
# error This implementation should happen inline in the include file
#endif
}
void BufferManager::CopyAudioDataToBuffer( Float32* inData, UInt32 NewNumSamples )
{
if (inData == NULL) return;
for (UInt32 i=0; i<NewNumSamples; i++)
{
if (i + _CurDataIdx >= _BufferLen)
_CurDataIdx = -i;
_AudioDataBuffer[i + _CurDataIdx] = inData[i];
}
_CurDataIdx += NewNumSamples;
// The following segment of codes assume that GetFFTOuput() is being continuously called!
if (_FFTStartIdx < _FFTEndIdx)
{
if (_FFTEndIdx < _CurDataIdx && NeedsNewFFTData())
{
//printf("_CurDataIdx: %ld\n", _CurDataIdx);
OSAtomicIncrement32(&_HasNewFFTData);
OSAtomicDecrement32(&_NeedsNewFFTData);
}
}
else if (_FFTEndIdx < _FFTStartIdx)
{
if (_FFTEndIdx < _CurDataIdx && _CurDataIdx < _FFTStartIdx && NeedsNewFFTData())
{
//printf("_CurDataIdx: %ld\n", _CurDataIdx);
OSAtomicIncrement32(&_HasNewFFTData);
OSAtomicDecrement32(&_NeedsNewFFTData);
}
}
else
printf("BufferManager::CopyAudioDataToBuffer() - this code should never execute!");
}
void *client(void *arg)
{
channel_t channel = (channel_t)arg;
uint32_t major_stat;
uint32_t minor_stat;
uint32_t rflags;
uint32_t inout_gssd_flags;
gssd_cred cred_handle = (gssd_cred) (uintptr_t)GSS_C_NO_CREDENTIAL;
gssd_ctx gss_context = (gssd_ctx) (uintptr_t)GSS_C_NO_CONTEXT;
kern_return_t kr;
int gss_error = 0;
int retry_count = 0;
char display_name[128];
do {
if (read_channel(1, channel)) {
Log("Bad read from server\n");
return (NULL);
}
if (verbose)
Debug("Calling mach_gss_init_sec_context from %p\n",
(void *) pthread_self());
deallocate(channel->ctoken, channel->ctokenCnt);
channel->ctoken = (gssd_byte_buffer)GSS_C_NO_BUFFER;
channel->ctokenCnt = 0;
retry:
switch (version) {
case 0:
case 1:
kr = mach_gss_init_sec_context(
client_mp,
mech,
channel->stoken, channel->stokenCnt,
uid,
principal,
svcname,
flags,
gssd_flags,
&gss_context,
&cred_handle,
&rflags,
&channel->clnt_skey, &channel->clnt_skeyCnt,
&channel->ctoken, &channel->ctokenCnt,
&major_stat,
&minor_stat);
break;
case 2:
inout_gssd_flags = gssd_flags;
kr = mach_gss_init_sec_context_v2(
client_mp,
mech,
channel->stoken, channel->stokenCnt,
uid,
clientp.nt,
clientp.name,
clientp.len,
targetp.nt,
targetp.name,
targetp.len,
flags,
&inout_gssd_flags,
&gss_context,
&cred_handle,
&rflags,
&channel->clnt_skey, &channel->clnt_skeyCnt,
&channel->ctoken, &channel->ctokenCnt,
display_name,
&major_stat,
&minor_stat);
if (verbose && kr == KERN_SUCCESS && major_stat == GSS_S_COMPLETE)
Debug("Got client identity of '%s'\n", display_name);
break;
default:
Log("Unsupported version %d\n", version);
exit(1);
break;
}
if (kr != KERN_SUCCESS) {
OSAtomicIncrement32(&server_errors);
Log("gsstest client: %s\n", mach_error_string(kr));
if (exitonerror)
exit(1);
if (kr == MIG_SERVER_DIED) {
OSAtomicIncrement32(&server_deaths);
if (gss_context == (uint32_t)(uintptr_t)GSS_C_NO_CONTEXT &&
retry_count < max_retries) {
retry_count++;
goto retry;
}
}
channel->failure = 1;
write_channel(1, channel);
return (NULL);
}
gss_error = (major_stat != GSS_S_COMPLETE &&
major_stat != GSS_S_CONTINUE_NEEDED);
if (verbose > 1) {
Debug("\tcred = 0x%0x\n", (int) cred_handle);
Debug("\tclnt_gss_context = 0x%0x\n",
(int) gss_context);
Debug("\ttokenCnt = %d\n", (int) channel->ctokenCnt);
if (verbose > 2)
HexDump((char *) channel->ctoken,
(uint32_t) channel->ctokenCnt);
}
channel->failure = gss_error;
write_channel(1, channel);
} while (major_stat == GSS_S_CONTINUE_NEEDED);
if (gss_error) {
OSAtomicIncrement32(&gss_init_errors);
Log("mach_gss_int_sec_context: %#K %#k\n", major_stat, mechtab[mech], minor_stat);
}
close_channel(1, channel);
return (NULL);
}
#include <stdio.h>
#include <CoreFoundation/CoreFoundation.h>
#ifdef __APPLE__
#include <libkern/OSAtomic.h>
#endif
#include <bsdtests.h>
#include "dispatch_test.h"
const int32_t final = 10;
static volatile int32_t count;
static void
work(void* ctxt __attribute__((unused)))
{
int32_t c = OSAtomicIncrement32(&count);
if (c < final-1) {
dispatch_async_f(dispatch_get_main_queue(), NULL, work);
CFRunLoopPerformBlock(CFRunLoopGetMain(), kCFRunLoopDefaultMode, ^{
fprintf(stderr, "CFRunLoopPerformBlock %d\n", c);
test_long_less_than("CFRunLoopPerformBlock", count, final);
});
}
}
int
main(void)
{
dispatch_test_start("Dispatch CF main queue"); // <rdar://problem/7760523>
dispatch_async_f(dispatch_get_main_queue(), NULL, work);
dispatch_async_f(dispatch_get_main_queue(), NULL, work);
long InterlockedIncrement(long volatile* Addend) {
return OSAtomicIncrement32(reinterpret_cast<int32_t volatile*>(Addend));
}
ULONG STDMETHODCALLTYPE DeckLink::AddRef(void) {
return OSAtomicIncrement32(&referenceCount);
};
static inline CFNotificationObserver *CFNotificationObserverRetain(CFAllocatorRef allocator, CFNotificationObserver *observer) {
observer->retainCount = OSAtomicIncrement32(&observer->retainCount);
return observer;
}
inline void AtomicIncrement(volatile esint32* i)
{
OSAtomicIncrement32(i);
}
template <typename T> static T inc(volatile T*scalar) {
return (T)OSAtomicIncrement32((int32*)scalar);
}
