onekopaka/Darwin-Streaming-Server
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Add even more of the source

Browse source 
This should be about everything needed to build so far?
This commit is contained in:
Darren VanBuren 2017-03-07 17:14:16 -08:00
parent af3619d4fa
commit 849723c9cf
547 changed files with 149239 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

249
CommonUtilitiesLib/mymutex.cpp Normal file
View file

@ -0,0 +1,249 @@
/*
* Copyright (c) 2003 Apple Computer, Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* Copyright (c) 1999-2008 Apple Inc. All Rights Reserved.
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
/*
File: mymutex.c
Contains: xxx put contents here xxx
Written by: Greg Vaughan
Writers:
(GV) Greg Vaughan
(CNR) Christopher Ryan
Change History (most recent first):
<7> 9/5/00 CNR Use mach_port_destroy instead of mach_port_deallocate in
MMDisposeMutex.
<6> 7/24/00 GV changed Carbon to CarbonCore for header include
<5> 1/11/00 CNR Fix for IncrementAtomic/DecrementAtomic return value.
<4> 1/6/00 GBV got rid of libatomic
<3> 12/8/99 CNR Use OSAssert.h
<2> 10/27/99 GBV update for beaker
To Do:
*/
#include "mymutex.h"
#include <stdlib.h>
#include "SafeStdLib.h"
#if __MacOSX__
#ifndef __CORESERVICES__
#include <CoreServices/CoreServices.h>
#endif
#endif
#include "MyAssert.h"
struct MyMutex
{
SInt32 fCount;
pthread_t fHolder;
UInt32 fMutexLock;
mach_port_t fWaitPort;
SInt32 fNumWaiting;
};
typedef struct MyMutex MyMutex;
MyMutex* MMAllocateMutex();
void MMDisposeMutex(MyMutex* theMutex);
void MMGrab(MyMutex* theMutex);
int MMTryGrab(MyMutex* theMutex);
void MMRelease(MyMutex* theMutex);
pthread_t MMGetFirstWaitingThread(MyMutex* theMutex, int* listWasEmpty);
int MMAlreadyHaveControl(MyMutex* theMutex, pthread_t thread);
int MMTryAndGetControl(MyMutex* theMutex, pthread_t thread);
void MMReleaseControl(MyMutex* theMutex);
void MMStripOffWaitingThread(MyMutex* theMutex);
void MMAddToWaitList(MyMutex* theMutex, pthread_t thread);
void MMBlockThread(MyMutex* theMutex);
void MMUnblockThread(MyMutex* theMutex);
mymutex_t mymutex_alloc()
{
return (mymutex_t)MMAllocateMutex();
}
void mymutex_free(mymutex_t theMutex_t)
{
MMDisposeMutex((MyMutex*)theMutex_t);
}
void mymutex_lock(mymutex_t theMutex_t)
{
MMGrab((MyMutex*)theMutex_t);
}
int mymutex_try_lock(mymutex_t theMutex_t)
{
return MMTryGrab((MyMutex*)theMutex_t);
}
void mymutex_unlock(mymutex_t theMutex_t)
{
MMRelease((MyMutex*)theMutex_t);
}
SInt32 sNumMutexes = 0;
MyMutex* MMAllocateMutex()
{
kern_return_t ret;
MyMutex* newMutex = (MyMutex*)malloc(sizeof(MyMutex));
if (newMutex == NULL)
{
Assert(newMutex != NULL);
return NULL;
}
newMutex->fCount = 0;
newMutex->fHolder = 0;
newMutex->fNumWaiting = 0;
newMutex->fMutexLock = 0;
ret = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &newMutex->fWaitPort);
if (ret != KERN_SUCCESS)
{
AssertV(ret == 0, ret);
free(newMutex);
return NULL;
}
ret = mach_port_insert_right(mach_task_self(), newMutex->fWaitPort, newMutex->fWaitPort, MACH_MSG_TYPE_MAKE_SEND);
if (ret != KERN_SUCCESS)
{
AssertV(ret == 0, ret);
free(newMutex);
return NULL;
}
AssertV(ret == 0, ret);
IncrementAtomic(&sNumMutexes);
return newMutex;
}
void MMDisposeMutex(MyMutex* theMutex)
{
int err = noErr;
err = mach_port_destroy(mach_task_self(), theMutex->fWaitPort);
DecrementAtomic(&sNumMutexes);
AssertV(err == noErr, err);
free(theMutex);
}
void MMGrab(MyMutex* theMutex)
{
pthread_t thread = pthread_self();
if (theMutex->fHolder != thread)
{
int waiting = IncrementAtomic(&theMutex->fNumWaiting) + 1;
if ((waiting > 1) || !CompareAndSwap(0, 1, &theMutex->fMutexLock))
{
do
{
// suspend ourselves until something happens
MMBlockThread(theMutex);
} while (!CompareAndSwap(0, 1, &theMutex->fMutexLock));
}
DecrementAtomic(&theMutex->fNumWaiting);
// we just got control, so reset fCount
theMutex->fCount = 0; // gets incremented below...
theMutex->fHolder = thread;
}
// we have control now, so increment the count
++theMutex->fCount;
}
int MMTryGrab(MyMutex* theMutex)
{
pthread_t thread = pthread_self();
int haveControl;
haveControl = (theMutex->fHolder == thread);
if (!haveControl)
haveControl = CompareAndSwap(0, 1, &theMutex->fMutexLock);
if (haveControl)
{
theMutex->fHolder = thread;
++theMutex->fCount;
}
return haveControl;
}
void MMRelease(MyMutex* theMutex)
{
pthread_t thread = pthread_self();
if (theMutex->fHolder != thread)
return;
if (!--theMutex->fCount)
{
theMutex->fHolder = NULL;
theMutex->fMutexLock = 0; // let someone else deal with it
if (theMutex->fNumWaiting > 0)
MMUnblockThread(theMutex);
}
}
typedef struct {
mach_msg_header_t header;
mach_msg_trailer_t trailer;
} mHeader;
void MMBlockThread(MyMutex* theMutex)
{
kern_return_t ret;
mHeader msg;
memset(&msg, 0, sizeof(msg));
ret = mach_msg(&msg.header,MACH_RCV_MSG,0,sizeof(msg),
theMutex->fWaitPort,MACH_MSG_TIMEOUT_NONE,MACH_PORT_NULL);
AssertV(ret == 0, ret);
}
void MMUnblockThread(MyMutex* theMutex)
{
kern_return_t ret;
mHeader msg;
memset(&msg, 0, sizeof(msg));
msg.header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0);
msg.header.msgh_size = sizeof msg - sizeof msg.trailer;
msg.header.msgh_local_port = MACH_PORT_NULL;
msg.header.msgh_remote_port = theMutex->fWaitPort;
msg.header.msgh_id = 0;
ret = mach_msg(&msg.header,MACH_SEND_MSG,msg.header.msgh_size,0,MACH_PORT_NULL,MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
AssertV(ret == 0, ret);
}