ca_client_context Struct Reference

#include "oldAccess.h"

Inheritance diagram for ca_client_context:

Collaboration diagram for ca_client_context:

Classes
class	noSocket

Public Member Functions
	ca_client_context (bool enablePreemptiveCallback=false)
virtual	~ca_client_context ()
void	changeExceptionEvent (caExceptionHandler *pfunc, void *arg)
void	registerForFileDescriptorCallBack (CAFDHANDLER *pFunc, void *pArg)
void	replaceErrLogHandler (caPrintfFunc *ca_printf_func)
cacChannel &	createChannel (epicsGuard< epicsMutex > &, const char *pChannelName, cacChannelNotify &, cacChannel::priLev pri)
void	flush (epicsGuard< epicsMutex > &)
void	eliminateExcessiveSendBacklog (epicsGuard< epicsMutex > &, cacChannel &)
int	pendIO (const double &timeout)
int	pendEvent (const double &timeout)
bool	ioComplete () const
void	show (unsigned level) const
unsigned	circuitCount () const
unsigned	sequenceNumberOfOutstandingIO (epicsGuard< epicsMutex > &) const
unsigned	beaconAnomaliesSinceProgramStart () const
void	incrementOutstandingIO (epicsGuard< epicsMutex > &, unsigned ioSeqNo)
void	decrementOutstandingIO (epicsGuard< epicsMutex > &, unsigned ioSeqNo)
void	blockForEventAndEnableCallbacks (epicsEvent &event, const double &timeout)
CASG *	lookupCASG (epicsGuard< epicsMutex > &, unsigned id)
void	installCASG (epicsGuard< epicsMutex > &, CASG &)
void	uninstallCASG (epicsGuard< epicsMutex > &, CASG &)
void	selfTest () const
int	printFormated (const char *pformat,...) const
int	varArgsPrintFormated (const char *pformat, va_list args) const
void	signal (int ca_status, const char *pfilenm, int lineno, const char *pFormat,...)
void	vSignal (int ca_status, const char *pfilenm, int lineno, const char *pFormat, va_list args)
bool	preemptiveCallbakIsEnabled () const
void	destroyGetCopy (epicsGuard< epicsMutex > &, getCopy &)
void	destroyGetCallback (epicsGuard< epicsMutex > &, getCallback &)
void	destroyPutCallback (epicsGuard< epicsMutex > &, putCallback &)
void	destroySubscription (epicsGuard< epicsMutex > &, oldSubscription &)
epicsMutex &	mutexRef () const
template<class T >
void	whenThereIsAnExceptionDestroySyncGroupIO (epicsGuard< epicsMutex > &, T &)
Public Member Functions inherited from cacContextNotify
virtual	~cacContextNotify ()=0

Static Public Member Functions
static void	installDefaultService (cacService &)

Public Attributes
void exception epicsGuard< epicsMutex > int	status
void exception epicsGuard< epicsMutex > int const char *	pContext
void exception epicsGuard< epicsMutex > int const char const char *	pFileName
void exception epicsGuard< epicsMutex > int const char const char unsigned	lineNo
void exception epicsGuard< epicsMutex > int const char const char unsigned oldChannelNotify &	chan
void exception epicsGuard< epicsMutex > int const char const char unsigned oldChannelNotify unsigned	type
void exception epicsGuard< epicsMutex > int const char const char unsigned oldChannelNotify unsigned arrayElementCount	count
void exception epicsGuard< epicsMutex > int const char const char unsigned oldChannelNotify unsigned arrayElementCount unsigned	op
Public Attributes inherited from cacContextNotify
virtual void exception epicsGuard< epicsMutex > int	status
virtual void exception epicsGuard< epicsMutex > int const char *	pContext
virtual void exception epicsGuard< epicsMutex > int const char const char *	pFileName
virtual void exception epicsGuard< epicsMutex > int const char const char unsigned	lineNo = 0

Friends
int epicsStdCall	ca_create_channel (const char *name_str, caCh *conn_func, void *puser, capri priority, chid *chanptr)
int epicsStdCall	ca_clear_channel (chid pChan)
int epicsStdCall	ca_array_get (chtype type, arrayElementCount count, chid pChan, void *pValue)
int epicsStdCall	ca_array_get_callback (chtype type, arrayElementCount count, chid pChan, caEventCallBackFunc *pfunc, void *arg)
int epicsStdCall	ca_array_put (chtype type, arrayElementCount count, chid pChan, const void *pValue)
int epicsStdCall	ca_array_put_callback (chtype type, arrayElementCount count, chid pChan, const void *pValue, caEventCallBackFunc *pfunc, void *usrarg)
int epicsStdCall	ca_create_subscription (chtype type, arrayElementCount count, chid pChan, long mask, caEventCallBackFunc *pCallBack, void *pCallBackArg, evid *monixptr)
int epicsStdCall	ca_flush_io ()
int epicsStdCall	ca_clear_subscription (evid pMon)
int epicsStdCall	ca_sg_create (CA_SYNC_GID *pgid)
int epicsStdCall	ca_sg_delete (const CA_SYNC_GID gid)
int epicsStdCall	ca_sg_block (const CA_SYNC_GID gid, ca_real timeout)
int epicsStdCall	ca_sg_reset (const CA_SYNC_GID gid)
int epicsStdCall	ca_sg_test (const CA_SYNC_GID gid)
int epicsStdCall	ca_sg_array_get (const CA_SYNC_GID gid, chtype type, arrayElementCount count, chid pChan, void *pValue)
int epicsStdCall	ca_sg_array_put (const CA_SYNC_GID gid, chtype type, arrayElementCount count, chid pChan, const void *pValue)
int	ca_sync_group_destroy (CallbackGuard &cbGuard, epicsGuard< epicsMutex > &guard, ca_client_context &cac, const CA_SYNC_GID gid)
void	sync_group_reset (ca_client_context &client, CASG &sg)
void	cacOnceFunc (void *)

Detailed Description

Definition at line 283 of file oldAccess.h.

Constructor & Destructor Documentation

ca_client_context::ca_client_context

(

bool

enablePreemptiveCallback = false

)

Definition at line 60 of file ca_client_context.cpp.

                                                                     :
    mutex(__FILE__, __LINE__),
    cbMutex(__FILE__, __LINE__),
    createdByThread ( epicsThreadGetIdSelf () ),
    ca_exception_func ( 0 ), ca_exception_arg ( 0 ),
    pVPrintfFunc ( errlogVprintf ), fdRegFunc ( 0 ), fdRegArg ( 0 ),
    pndRecvCnt ( 0u ), ioSeqNo ( 0u ), callbackThreadsPending ( 0u ),
    localPort ( 0 ), fdRegFuncNeedsToBeCalled ( false ),
    noWakeupSincePend ( true )
{
    static const unsigned short PORT_ANY = 0u;

    if ( ! osiSockAttach () ) {
        throwWithLocation ( noSocket () );
    }

    epicsThreadOnce ( & cacOnce, cacOnceFunc, 0 );
    {
        epicsGuard < epicsMutex > guard ( *ca_client_context::pDefaultServiceInstallMutex );
        if ( ca_client_context::pDefaultService ) {
            this->pServiceContext.reset (
                & ca_client_context::pDefaultService->contextCreate (
                    this->mutex, this->cbMutex, *this ) );
        }
        else {
            this->pServiceContext.reset ( new cac ( this->mutex, this->cbMutex, *this ) );
        }
    }

    this->sock = epicsSocketCreate ( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
    if ( this->sock == INVALID_SOCKET ) {
        char sockErrBuf[64];
        epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
        this->printFormated (
            "ca_client_context: unable to create "
            "datagram socket because = \"%s\"\n",
            sockErrBuf );
        throwWithLocation ( noSocket () );
    }

    {
        osiSockIoctl_t yes = true;
        int status = socket_ioctl ( this->sock,
                                    FIONBIO, & yes);
        if ( status < 0 ) {
            char sockErrBuf[64];
            epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
            epicsSocketDestroy ( this->sock );
            this->printFormated (
                "%s: non blocking IO set fail because \"%s\"\n",
                            __FILE__, sockErrBuf );
            throwWithLocation ( noSocket () );
        }
    }

    // force a bind to an unconstrained address so we can obtain
    // the local port number below
    {
        osiSockAddr addr;
        memset ( (char *)&addr, 0 , sizeof ( addr ) );
        addr.ia.sin_family = AF_INET;
        addr.ia.sin_addr.s_addr = htonl ( INADDR_ANY );
        addr.ia.sin_port = htons ( PORT_ANY );
        int status = bind (this->sock, &addr.sa, sizeof (addr) );
        if ( status < 0 ) {
            char sockErrBuf[64];
            epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
            epicsSocketDestroy (this->sock);
            this->printFormated (
                "CAC: unable to bind to an unconstrained "
                "address because = \"%s\"\n",
                sockErrBuf );
            throwWithLocation ( noSocket () );
        }
    }

    {
        osiSockAddr tmpAddr;
        osiSocklen_t saddr_length = sizeof ( tmpAddr );
        int status = getsockname ( this->sock, & tmpAddr.sa, & saddr_length );
        if ( status < 0 ) {
            char sockErrBuf[64];
            epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
            epicsSocketDestroy ( this->sock );
            this->printFormated ( "CAC: getsockname () error was \"%s\"\n", sockErrBuf );
            throwWithLocation ( noSocket () );
        }
        if ( tmpAddr.sa.sa_family != AF_INET) {
            epicsSocketDestroy ( this->sock );
            this->printFormated ( "CAC: UDP socket was not inet addr family\n" );
            throwWithLocation ( noSocket () );
        }
        this->localPort = htons ( tmpAddr.ia.sin_port );
    }

    std::auto_ptr < CallbackGuard > pCBGuard;
    if ( ! enablePreemptiveCallback ) {
        pCBGuard.reset ( new CallbackGuard ( this->cbMutex ) );
    }

    // multiple steps ensure exception safety
    this->pCallbackGuard = pCBGuard;
}

ca_client_context::~ca_client_context ( )

virtual

Definition at line 164 of file ca_client_context.cpp.

{
    if ( this->fdRegFunc ) {
        ( *this->fdRegFunc )
            ( this->fdRegArg, this->sock, false );
    }
    epicsSocketDestroy ( this->sock );

    osiSockRelease ();

    // force a logical shutdown order
    // so that the cac class does not hang its
    // receive threads during their shutdown sequence
    // and so that classes using this classes mutex
    // are destroyed before the mutex is destroyed
    if ( this->pCallbackGuard.get() ) {
        epicsGuardRelease < epicsMutex > unguard ( *this->pCallbackGuard );
        this->pServiceContext.reset ( 0 );
    }
    else {
        this->pServiceContext.reset ( 0 );
    }
}

Member Function Documentation

unsigned ca_client_context::beaconAnomaliesSinceProgramStart

(

)

const

Definition at line 675 of file ca_client_context.cpp.

{
    epicsGuard < epicsMutex > guard ( this->mutex );
    return this->pServiceContext->beaconAnomaliesSinceProgramStart ( guard );
}

void ca_client_context::blockForEventAndEnableCallbacks	(	epicsEvent &	event,
		const double &	timeout
	)

Definition at line 588 of file ca_client_context.cpp.

{
    if ( this->pCallbackGuard.get() ) {
        epicsGuardRelease < epicsMutex > unguard ( *this->pCallbackGuard );
        event.wait ( timeout );
    }
    else {
        event.wait ( timeout );
    }
}

void ca_client_context::changeExceptionEvent	(	caExceptionHandler *	pfunc,
		void *	arg
	)

Definition at line 220 of file ca_client_context.cpp.

{
    epicsGuard < epicsMutex > guard ( this->mutex );
    this->ca_exception_func = pfunc;
    this->ca_exception_arg = arg;
// should block here until releated callback in progress completes
}

unsigned ca_client_context::circuitCount

(

)

const

Definition at line 669 of file ca_client_context.cpp.

{
    epicsGuard < epicsMutex > guard ( this->mutex );
    return this->pServiceContext->circuitCount ( guard );
}

cacChannel & ca_client_context::createChannel	(	epicsGuard< epicsMutex > &	guard,
		const char *	pChannelName,
		cacChannelNotify &	chan,
		cacChannel::priLev	pri
	)

Definition at line 655 of file ca_client_context.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );
    return this->pServiceContext->createChannel (
        guard, pChannelName, chan, pri );
}

void ca_client_context::decrementOutstandingIO	(	epicsGuard< epicsMutex > &	guard,
		unsigned	ioSeqNo
	)

Definition at line 449 of file ca_client_context.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );
    if ( this->ioSeqNo == ioSeqNoIn ) {
        assert ( this->pndRecvCnt > 0u );
        this->pndRecvCnt--;
        if ( this->pndRecvCnt == 0u ) {
            this->ioDone.signal ();
        }
    }
}

void ca_client_context::destroyGetCallback	(	epicsGuard< epicsMutex > &	guard,
		getCallback &	gcb
	)

Definition at line 196 of file ca_client_context.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );
    gcb.~getCallback ();
    this->getCallbackFreeList.release ( & gcb );
}

void ca_client_context::destroyGetCopy	(	epicsGuard< epicsMutex > &	guard,
		getCopy &	gc
	)

Definition at line 188 of file ca_client_context.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );
    gc.~getCopy ();
    this->getCopyFreeList.release ( & gc );
}

void ca_client_context::destroyPutCallback	(	epicsGuard< epicsMutex > &	guard,
		putCallback &	pcb
	)

Definition at line 204 of file ca_client_context.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );
    pcb.~putCallback ();
    this->putCallbackFreeList.release ( & pcb );
}

void ca_client_context::destroySubscription	(	epicsGuard< epicsMutex > &	guard,
		oldSubscription &	os
	)

Definition at line 212 of file ca_client_context.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );
    os.~oldSubscription ();
    this->subscriptionFreeList.release ( & os );
}

void ca_client_context::eliminateExcessiveSendBacklog	(	epicsGuard< epicsMutex > &	guard,
		cacChannel &	chan
	)

Definition at line 781 of file ca_client_context.cpp.

{
    if ( chan.requestMessageBytesPending ( guard ) >
            ca_client_context :: flushBlockThreshold ) {
        if ( this->pCallbackGuard.get() &&
            this->createdByThread == epicsThreadGetIdSelf () ) {
            // we need to be very careful about lock hierarchy
            // inversion in this situation
            epicsGuardRelease < epicsMutex > unguard ( guard );
            {
                epicsGuardRelease < epicsMutex > cbunguard (
                    * this->pCallbackGuard.get() );
                {
                    epicsGuard < epicsMutex > nestedGuard ( this->mutex );
                    chan.flush ( nestedGuard );
                }
            }
        }
        else {
            chan.flush ( guard );
        }
    }
}

void ca_client_context::flush

(

epicsGuard< epicsMutex > &

guard

)

Definition at line 664 of file ca_client_context.cpp.

{
    this->pServiceContext->flush ( guard );
}

void ca_client_context::incrementOutstandingIO	(	epicsGuard< epicsMutex > &	guard,
		unsigned	ioSeqNo
	)

Definition at line 439 of file ca_client_context.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );
    if ( this->ioSeqNo == ioSeqNoIn ) {
        assert ( this->pndRecvCnt < UINT_MAX );
        this->pndRecvCnt++;
    }
}

void ca_client_context::installCASG	(	epicsGuard< epicsMutex > &	guard,
		CASG &	sg
	)

Definition at line 681 of file ca_client_context.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );
    this->sgTable.idAssignAdd ( sg );
}

void ca_client_context::installDefaultService ( cacService &  service )

static

Definition at line 726 of file ca_client_context.cpp.

{
    epicsThreadOnce ( & cacOnce, cacOnceFunc, 0 );

    epicsGuard < epicsMutex > guard ( *ca_client_context::pDefaultServiceInstallMutex );
    if ( ca_client_context::pDefaultService ) {
        throw std::logic_error
            ( "CA in-memory service already installed and can't be replaced");
    }
    ca_client_context::pDefaultService = & service;
}

bool ca_client_context::ioComplete ( ) const

inline

Definition at line 561 of file oldAccess.h.

{
    return ( this->pndRecvCnt == 0u );
}

CASG * ca_client_context::lookupCASG	(	epicsGuard< epicsMutex > &	guard,
		unsigned	id
	)

Definition at line 695 of file ca_client_context.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );
    CASG * psg = this->sgTable.lookup ( idIn );
    if ( psg ) {
        if ( ! psg->verify ( guard ) ) {
            psg = 0;
        }
    }
    return psg;
}

epicsMutex & ca_client_context::mutexRef

(

)

const

Definition at line 715 of file ca_client_context.cpp.

{
    return this->mutex;
}

int ca_client_context::pendEvent

(

const double &

timeout

)

Definition at line 516 of file ca_client_context.cpp.

{
    // prevent recursion nightmares by disabling calls to
    // pendIO () from within a CA callback.
    if ( epicsThreadPrivateGet ( caClientCallbackThreadId ) ) {
        return ECA_EVDISALLOW;
    }

    epicsTime current = epicsTime::getCurrent ();

    {
        epicsGuard < epicsMutex > guard ( this->mutex );
        this->flush ( guard );
    }

    // process at least once if preemptive callback is disabled
    if ( this->pCallbackGuard.get() ) {
        epicsGuardRelease < epicsMutex > cbUnguard ( *this->pCallbackGuard );
        epicsGuard < epicsMutex > guard ( this->mutex );

        //
        // This is needed because in non-preemptive callback mode
        // legacy applications that use file descriptor managers
        // will register for ca receive thread activity and keep
        // calling ca_pend_event until all of the socket data has
        // been read. We must guarantee that other threads get a
        // chance to run if there is data in any of the sockets.
        //
        if ( this->fdRegFunc ) {
            epicsGuardRelease < epicsMutex > unguard ( guard );

            // remove short udp message sent to wake
            // up a file descriptor manager
            osiSockAddr tmpAddr;
            osiSocklen_t addrSize = sizeof ( tmpAddr.sa );
            char buf = 0;
            int status = 0;
            do {
                status = recvfrom ( this->sock, & buf, sizeof ( buf ),
                        0, & tmpAddr.sa, & addrSize );
            } while ( status > 0 );
        }
        while ( this->callbackThreadsPending > 0 ) {
            epicsGuardRelease < epicsMutex > unguard ( guard );
            this->callbackThreadActivityComplete.wait ( 30.0 );
        }
        this->noWakeupSincePend = true;
    }

    double elapsed = epicsTime::getCurrent() - current;
    double delay;

    if ( timeout > elapsed ) {
        delay = timeout - elapsed;
    }
    else {
        delay = 0.0;
    }

    if ( delay >= CAC_SIGNIFICANT_DELAY ) {
        if ( this->pCallbackGuard.get() ) {
            epicsGuardRelease < epicsMutex > unguard ( *this->pCallbackGuard );
            epicsThreadSleep ( delay );
        }
        else {
            epicsThreadSleep ( delay );
        }
    }

    return ECA_TIMEOUT;
}

int ca_client_context::pendIO

(

const double &

timeout

)

Definition at line 468 of file ca_client_context.cpp.

{
    // prevent recursion nightmares by disabling calls to
    // pendIO () from within a CA callback.
    if ( epicsThreadPrivateGet ( caClientCallbackThreadId ) ) {
        return ECA_EVDISALLOW;
    }

    int status = ECA_NORMAL;
    epicsTime beg_time = epicsTime::getCurrent ();
    double remaining = timeout;

    epicsGuard < epicsMutex > guard ( this->mutex );

    this->flush ( guard );

    while ( this->pndRecvCnt > 0 ) {
        if ( remaining < CAC_SIGNIFICANT_DELAY ) {
            status = ECA_TIMEOUT;
            break;
        }

        {
            epicsGuardRelease < epicsMutex > unguard ( guard );
            this->blockForEventAndEnableCallbacks ( this->ioDone, remaining );
        }

        double delay = epicsTime::getCurrent () - beg_time;
        if ( delay < timeout ) {
            remaining = timeout - delay;
        }
        else {
            remaining = 0.0;
        }
    }

    this->ioSeqNo++;
    this->pndRecvCnt = 0u;

    return status;
}

bool ca_client_context::preemptiveCallbakIsEnabled ( ) const

inline

Definition at line 556 of file oldAccess.h.

{
    return this->pCallbackGuard.get () == 0;
}

int ca_client_context::printFormated	(	const char *	pformat,
			...
	)		const

Definition at line 257 of file ca_client_context.cpp.

{
    va_list theArgs;
    int status;

    va_start ( theArgs, pformat );

    status = this->ca_client_context :: varArgsPrintFormated ( pformat, theArgs );

    va_end ( theArgs );

    return status;
}

void ca_client_context::registerForFileDescriptorCallBack	(	CAFDHANDLER *	pFunc,
		void *	pArg
	)

Definition at line 242 of file ca_client_context.cpp.

{
    epicsGuard < epicsMutex > guard ( this->mutex );
    this->fdRegFunc = pFunc;
    this->fdRegArg = pArg;
    this->fdRegFuncNeedsToBeCalled = true;
    if ( pFunc ) {
        // the receive thread might already be blocking
        // w/o having sent the wakeup message
        this->_sendWakeupMsg ();
    }
// should block here until releated callback in progress completes
}

void ca_client_context::replaceErrLogHandler

(

caPrintfFunc *

ca_printf_func

)

Definition at line 229 of file ca_client_context.cpp.

{
    epicsGuard < epicsMutex > guard ( this->mutex );
    if ( ca_printf_func ) {
        this->pVPrintfFunc = ca_printf_func;
    }
    else {
        this->pVPrintfFunc = epicsVprintf;
    }
// should block here until releated callback in progress completes
}

void ca_client_context::selfTest

(

)

const

Definition at line 708 of file ca_client_context.cpp.

{
    epicsGuard < epicsMutex > guard ( this->mutex );
    this->sgTable.verify ();
    this->pServiceContext->selfTest ( guard );
}

unsigned ca_client_context::sequenceNumberOfOutstandingIO ( epicsGuard< epicsMutex > &  ) const

inline

Definition at line 566 of file oldAccess.h.

{
    // perhaps on SMP systems THERE should be lock/unlock around this
    return this->ioSeqNo;
}

void ca_client_context::show

(

unsigned

level

)

const

Definition at line 410 of file ca_client_context.cpp.

{
    epicsGuard < epicsMutex > guard ( this->mutex );

    ::printf ( "ca_client_context at %p pndRecvCnt=%u ioSeqNo=%u\n",
        static_cast <const void *> ( this ),
        this->pndRecvCnt, this->ioSeqNo );

    if ( level > 0u ) {
        this->pServiceContext->show ( guard, level - 1u );
        ::printf ( "\tpreemptive callback is %s\n",
            this->pCallbackGuard.get() ? "disabled" : "enabled" );
        ::printf ( "\tthere are %u unsatisfied IO operations blocking ca_pend_io()\n",
                this->pndRecvCnt );
        ::printf ( "\tthe current io sequence number is %u\n",
                this->ioSeqNo );
        ::printf ( "IO done event:\n");
        this->ioDone.show ( level - 1u );
        ::printf ( "Synchronous group identifier hash table:\n" );
        this->sgTable.show ( level - 1u );
    }
}

void ca_client_context::signal	(	int	ca_status,
		const char *	pfilenm,
		int	lineno,
		const char *	pFormat,
			...
	)

Definition at line 351 of file ca_client_context.cpp.

{
    va_list theArgs;
    va_start ( theArgs, pFormat );
    this->vSignal ( ca_status, pfilenm, lineno, pFormat, theArgs);
    va_end ( theArgs );
}

void ca_client_context::uninstallCASG	(	epicsGuard< epicsMutex > &	guard,
		CASG &	sg
	)

Definition at line 688 of file ca_client_context.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );
    this->sgTable.remove ( sg );
}

int ca_client_context::varArgsPrintFormated ( const char *  pformat, va_list  args  ) const

virtual

Implements cacContextNotify.

Definition at line 272 of file ca_client_context.cpp.

{
    caPrintfFunc * pFunc;
    {
        epicsGuard < epicsMutex > guard ( this->mutex );
        pFunc = this->pVPrintfFunc;
    }
    if ( pFunc ) {
        return ( *pFunc ) ( pformat, args );
    }
    else {
        return :: vfprintf ( stderr, pformat, args );
    }
}

void ca_client_context::vSignal	(	int	ca_status,
		const char *	pfilenm,
		int	lineno,
		const char *	pFormat,
		va_list	args
	)

Definition at line 360 of file ca_client_context.cpp.

{
    static const char *severity[] =
    {
        "Warning",
        "Success",
        "Error",
        "Info",
        "Fatal",
        "Fatal",
        "Fatal",
        "Fatal"
    };

    this->printFormated ( "CA.Client.Exception...............................................\n" );

    this->printFormated ( "    %s: \"%s\"\n",
        severity[ CA_EXTRACT_SEVERITY ( ca_status ) ],
        ca_message ( ca_status ) );

    if  ( pFormat ) {
        this->printFormated ( "    Context: \"" );
        this->varArgsPrintFormated ( pFormat, args );
        this->printFormated ( "\"\n" );
    }

    if ( pfilenm ) {
        this->printFormated ( "    Source File: %s line %d\n",
            pfilenm, lineno );
    }

    epicsTime current = epicsTime::getCurrent ();
    char date[64];
    current.strftime ( date, sizeof ( date ), "%a %b %d %Y %H:%M:%S.%f");
    this->printFormated ( "    Current Time: %s\n", date );

    /*
     *  Terminate execution if unsuccessful
     */
    if( ! ( ca_status & CA_M_SUCCESS ) &&
        CA_EXTRACT_SEVERITY ( ca_status ) != CA_K_WARNING ){
        errlogFlush ();
        abort ();
    }

    this->printFormated ( "..................................................................\n" );
}

template<class T >

void ca_client_context::whenThereIsAnExceptionDestroySyncGroupIO	(	epicsGuard< epicsMutex > &	guard,
		T &	io
	)

Definition at line 574 of file oldAccess.h.

{
    if ( this->pCallbackGuard.get() &&
        this->createdByThread == epicsThreadGetIdSelf () ) {
        io.destroy ( *this->pCallbackGuard.get(), guard );
    }
    else {
        // dont reverse the lock hierarchy
        epicsGuardRelease < epicsMutex > guardRelease ( guard );
        {
            //
            // we will definately stall out here if all of the
            // following are true
            //
            // o user creates non-preemtive mode client library context
            // o user doesnt periodically call a ca function
            // o user calls this function from an auxiillary thread
            //
            CallbackGuard cbGuard ( this->cbMutex );
            epicsGuard < epicsMutex > guard ( this->mutex );
            io.destroy ( cbGuard, guard );
        }
    }
}

Friends And Related Function Documentation

int epicsStdCall ca_array_get ( chtype  type, arrayElementCount  count, chid  pChan, void *  pValue  )

friend

Definition at line 267 of file oldChannelNotify.cpp.

{
    int caStatus;
    try {
        if ( type < 0 ) {
            return ECA_BADTYPE;
        }
        if ( count == 0 )
            return ECA_BADCOUNT;

        unsigned tmpType = static_cast < unsigned > ( type );
        epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
        pChan->eliminateExcessiveSendBacklog ( guard );
        autoPtrFreeList < getCopy, 0x400, epicsMutexNOOP > pNotify
            ( pChan->getClientCtx().getCopyFreeList,
                new ( pChan->getClientCtx().getCopyFreeList )
                    getCopy ( guard, pChan->getClientCtx(), *pChan,
                                tmpType, count, pValue ) );
        pChan->io.read ( guard, type, count, *pNotify, 0 );
        pNotify.release ();
        caStatus = ECA_NORMAL;
    }
    catch ( cacChannel::badString & )
    {
        caStatus = ECA_BADSTR;
    }
    catch ( cacChannel::badType & )
    {
        caStatus = ECA_BADTYPE;
    }
    catch ( cacChannel::outOfBounds & )
    {
        caStatus = ECA_BADCOUNT;
    }
    catch ( cacChannel::noReadAccess & )
    {
        caStatus = ECA_NORDACCESS;
    }
    catch ( cacChannel::notConnected & )
    {
        caStatus = ECA_DISCONN;
    }
    catch ( cacChannel::unsupportedByService & )
    {
        caStatus = ECA_UNAVAILINSERV;
    }
    catch ( cacChannel::requestTimedOut & )
    {
        caStatus = ECA_TIMEOUT;
    }
    catch ( std::bad_alloc & )
    {
        caStatus = ECA_ALLOCMEM;
    }
    catch ( cacChannel::msgBodyCacheTooSmall & ) {
        caStatus = ECA_TOLARGE;
    }
    catch ( ... )
    {
        caStatus = ECA_GETFAIL;
    }
    return caStatus;
}

int epicsStdCall ca_array_get_callback ( chtype  type, arrayElementCount  count, chid  pChan, caEventCallBackFunc *  pfunc, void *  arg  )

friend

Definition at line 335 of file oldChannelNotify.cpp.

{
    int caStatus;
    try {
        if ( type < 0 ) {
            return ECA_BADTYPE;
        }
        if ( pfunc == NULL ) {
            return ECA_BADFUNCPTR;
        }
        unsigned tmpType = static_cast < unsigned > ( type );

        epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
        pChan->eliminateExcessiveSendBacklog ( guard );
        autoPtrFreeList < getCallback, 0x400, epicsMutexNOOP > pNotify
            ( pChan->getClientCtx().getCallbackFreeList,
            new ( pChan->getClientCtx().getCallbackFreeList )
                getCallback ( *pChan, pfunc, arg ) );
        pChan->io.read ( guard, tmpType, count, *pNotify, 0 );
        pNotify.release ();
        caStatus = ECA_NORMAL;
    }
    catch ( cacChannel::badString & )
    {
        caStatus = ECA_BADSTR;
    }
    catch ( cacChannel::badType & )
    {
        caStatus = ECA_BADTYPE;
    }
    catch ( cacChannel::outOfBounds & )
    {
        caStatus = ECA_BADCOUNT;
    }
    catch ( cacChannel::noReadAccess & )
    {
        caStatus = ECA_NORDACCESS;
    }
    catch ( cacChannel::notConnected & )
    {
        caStatus = ECA_DISCONN;
    }
    catch ( cacChannel::unsupportedByService & )
    {
        caStatus = ECA_UNAVAILINSERV;
    }
    catch ( cacChannel::requestTimedOut & )
    {
        caStatus = ECA_TIMEOUT;
    }
    catch ( std::bad_alloc & )
    {
        caStatus = ECA_ALLOCMEM;
    }
    catch ( cacChannel::msgBodyCacheTooSmall & ) {
        caStatus = ECA_TOLARGE;
    }
    catch ( ... )
    {
        caStatus = ECA_GETFAIL;
    }
    return caStatus;
}

int epicsStdCall ca_array_put ( chtype  type, arrayElementCount  count, chid  pChan, const void *  pValue  )

friend

Definition at line 476 of file oldChannelNotify.cpp.

{
    if ( type < 0 ) {
        return ECA_BADTYPE;
    }
    unsigned tmpType = static_cast < unsigned > ( type );

    int caStatus;
    try {
        epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
        pChan->eliminateExcessiveSendBacklog ( guard );
        pChan->io.write ( guard, tmpType, count, pValue );
        caStatus = ECA_NORMAL;
    }
    catch ( cacChannel::badString & )
    {
        caStatus = ECA_BADSTR;
    }
    catch ( cacChannel::badType & )
    {
        caStatus = ECA_BADTYPE;
    }
    catch ( cacChannel::outOfBounds & )
    {
        caStatus = ECA_BADCOUNT;
    }
    catch ( cacChannel::noWriteAccess & )
    {
        caStatus = ECA_NOWTACCESS;
    }
    catch ( cacChannel::notConnected & )
    {
        caStatus = ECA_DISCONN;
    }
    catch ( cacChannel::unsupportedByService & )
    {
        caStatus = ECA_UNAVAILINSERV;
    }
    catch ( cacChannel::requestTimedOut & )
    {
        caStatus = ECA_TIMEOUT;
    }
    catch ( std::bad_alloc & )
    {
        caStatus = ECA_ALLOCMEM;
    }
    catch ( ... )
    {
        caStatus = ECA_PUTFAIL;
    }
    return caStatus;
}

int epicsStdCall ca_array_put_callback ( chtype  type, arrayElementCount  count, chid  pChan, const void *  pValue, caEventCallBackFunc *  pfunc, void *  usrarg  )

friend

Definition at line 412 of file oldChannelNotify.cpp.

{
    int caStatus;
    try {
        if ( type < 0 ) {
            return ECA_BADTYPE;
        }
        if ( pfunc == NULL ) {
            return ECA_BADFUNCPTR;
        }
        epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
        pChan->eliminateExcessiveSendBacklog ( guard );
        unsigned tmpType = static_cast < unsigned > ( type );
        autoPtrFreeList < putCallback, 0x400, epicsMutexNOOP > pNotify
                ( pChan->getClientCtx().putCallbackFreeList,
                    new ( pChan->getClientCtx().putCallbackFreeList )
                        putCallback ( *pChan, pfunc, usrarg ) );
        pChan->io.write ( guard, tmpType, count, pValue, *pNotify, 0 );
        pNotify.release ();
        caStatus = ECA_NORMAL;
    }
    catch ( cacChannel::badString & )
    {
        caStatus = ECA_BADSTR;
    }
    catch ( cacChannel::badType & )
    {
        caStatus = ECA_BADTYPE;
    }
    catch ( cacChannel::outOfBounds & )
    {
        caStatus = ECA_BADCOUNT;
    }
    catch ( cacChannel::noWriteAccess & )
    {
        caStatus = ECA_NOWTACCESS;
    }
    catch ( cacChannel::notConnected & )
    {
        caStatus = ECA_DISCONN;
    }
    catch ( cacChannel::unsupportedByService & )
    {
        caStatus = ECA_UNAVAILINSERV;
    }
    catch ( cacChannel::requestTimedOut & )
    {
        caStatus = ECA_TIMEOUT;
    }
    catch ( std::bad_alloc & )
    {
        caStatus = ECA_ALLOCMEM;
    }
    catch ( ... )
    {
        caStatus = ECA_PUTFAIL;
    }
    return caStatus;
}

int epicsStdCall ca_clear_channel ( chid  pChan )

friend

Definition at line 363 of file access.cpp.

{
    ca_client_context & cac = pChan->getClientCtx ();
    {
        epicsGuard < epicsMutex > guard ( cac.mutex );
        try {
            pChan->eliminateExcessiveSendBacklog ( guard );
        }
        catch ( cacChannel::notConnected & ) {
            // intentionally ignored
        }
    }
    if ( cac.pCallbackGuard.get() &&
            cac.createdByThread == epicsThreadGetIdSelf () ) {
        epicsGuard < epicsMutex > guard ( cac.mutex );
        pChan->destructor ( *cac.pCallbackGuard.get(), guard );
        cac.oldChannelNotifyFreeList.release ( pChan );
    }
    else {
        //
        // we will definately stall out here if all of the
        // following are true
        //
        // o user creates non-preemtive mode client library context
        // o user doesnt periodically call a ca function
        // o user calls this function from an auxiillary thread
        //
        CallbackGuard cbGuard ( cac.cbMutex );
        epicsGuard < epicsMutex > guard ( cac.mutex );
        pChan->destructor ( *cac.pCallbackGuard.get(), guard );
        cac.oldChannelNotifyFreeList.release ( pChan );
    }
    return ECA_NORMAL;
}

int epicsStdCall ca_clear_subscription ( evid  pMon )

friend

Definition at line 743 of file ca_client_context.cpp.

{
    oldChannelNotify & chan = pMon->channel ();
    ca_client_context & cac = chan.getClientCtx ();
    // !!!! the order in which we take the mutex here prevents deadlocks
    {
        epicsGuard < epicsMutex > guard ( cac.mutex );
        try {
            // if this stalls out on a live circuit then an exception
            // can be forthcoming which we must ignore as the clear
            // request must always be successful
            chan.eliminateExcessiveSendBacklog ( guard );
        }
        catch ( cacChannel::notConnected & ) {
            // intentionally ignored
        }
    }
    if ( cac.pCallbackGuard.get() &&
        cac.createdByThread == epicsThreadGetIdSelf () ) {
      epicsGuard < epicsMutex > guard ( cac.mutex );
      pMon->cancel ( *cac.pCallbackGuard.get(), guard );
    }
    else {
      //
      // we will definately stall out here if all of the
      // following are true
      //
      // o user creates non-preemtive mode client library context
      // o user doesnt periodically call a ca function
      // o user calls this function from an auxiillary thread
      //
      CallbackGuard cbGuard ( cac.cbMutex );
      epicsGuard < epicsMutex > guard ( cac.mutex );
      pMon->cancel ( cbGuard, guard );
    }
    return ECA_NORMAL;
}

int epicsStdCall ca_create_channel ( const char *  name_str, caCh *  conn_func, void *  puser, capri  priority, chid *  chanptr  )

friend

Definition at line 288 of file access.cpp.

{
    ca_client_context * pcac;
    int caStatus = fetchClientContext ( & pcac );
    if ( caStatus != ECA_NORMAL ) {
        return caStatus;
    }

    {
        CAFDHANDLER * pFunc = 0;
        void * pArg = 0;
        {
            epicsGuard < epicsMutex >
                guard ( pcac->mutex );
            if ( pcac->fdRegFuncNeedsToBeCalled ) {
                pFunc = pcac->fdRegFunc;
                pArg = pcac->fdRegArg;
                pcac->fdRegFuncNeedsToBeCalled = false;
            }
        }
        if ( pFunc ) {
            ( *pFunc ) ( pArg, pcac->sock, true );
        }
    }

    try {
        epicsGuard < epicsMutex > guard ( pcac->mutex );
        oldChannelNotify * pChanNotify =
            new ( pcac->oldChannelNotifyFreeList )
                oldChannelNotify ( guard, *pcac, name_str,
                    conn_func, puser, priority );
        // make sure that their chan pointer is set prior to
        // calling connection call backs
        *chanptr = pChanNotify;
        pChanNotify->initiateConnect ( guard );
        // no need to worry about a connect preempting here because
        // the connect sequence will not start untill initiateConnect()
        // is called
    }
    catch ( cacChannel::badString & ) {
        return ECA_BADSTR;
    }
    catch ( std::bad_alloc & ) {
        return ECA_ALLOCMEM;
    }
    catch ( cacChannel::badPriority & ) {
        return ECA_BADPRIORITY;
    }
    catch ( cacChannel::unsupportedByService & ) {
        return ECA_UNAVAILINSERV;
    }
    catch ( std :: exception & except ) {
        pcac->printFormated (
            "ca_create_channel: "
            "unexpected exception was \"%s\"",
            except.what () );
        return ECA_INTERNAL;
    }
    catch ( ... ) {
        return ECA_INTERNAL;
    }

    return ECA_NORMAL;
}

int epicsStdCall ca_create_subscription ( chtype  type, arrayElementCount  count, chid  pChan, long  mask, caEventCallBackFunc *  pCallBack, void *  pCallBackArg, evid *  monixptr  )

friend

Definition at line 530 of file oldChannelNotify.cpp.

{
    if ( type < 0 ) {
        return ECA_BADTYPE;
    }
    unsigned tmpType = static_cast < unsigned > ( type );

    if ( INVALID_DB_REQ (type) ) {
        return ECA_BADTYPE;
    }

    if ( pCallBack == NULL ) {
        return ECA_BADFUNCPTR;
    }

    static const long maskMask = 0xffff;
    if ( ( mask & maskMask ) == 0) {
        return ECA_BADMASK;
    }

    if ( mask & ~maskMask ) {
        return ECA_BADMASK;
    }

    try {
        epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
        try {
            // if this stalls out on a live circuit then an exception
            // can be forthcoming which we must ignore (this is a
            // special case preserving legacy ca_create_subscription
            // behavior)
            pChan->eliminateExcessiveSendBacklog ( guard );
        }
        catch ( cacChannel::notConnected & ) {
            // intentionally ignored (its ok to subscribe when not connected)
        }
        new ( pChan->getClientCtx().subscriptionFreeList )
            oldSubscription  (
                guard, *pChan, pChan->io, tmpType, count, mask,
                pCallBack, pCallBackArg, monixptr );
        // dont touch object created after above new because
        // the first callback might have canceled, and therefore
        // destroyed, it
        return ECA_NORMAL;
    }
    catch ( cacChannel::badType & )
    {
        return ECA_BADTYPE;
    }
    catch ( cacChannel::outOfBounds & )
    {
        return ECA_BADCOUNT;
    }
    catch ( cacChannel::badEventSelection & )
    {
        return ECA_BADMASK;
    }
    catch ( cacChannel::noReadAccess & )
    {
        return ECA_NORDACCESS;
    }
    catch ( cacChannel::unsupportedByService & )
    {
        return ECA_UNAVAILINSERV;
    }
    catch ( std::bad_alloc & )
    {
        return ECA_ALLOCMEM;
    }
    catch ( cacChannel::msgBodyCacheTooSmall & ) {
        return ECA_TOLARGE;
    }
    catch ( ... )
    {
        return ECA_INTERNAL;
    }
}

int epicsStdCall ca_flush_io ( )

friend

Definition at line 509 of file access.cpp.

{
    ca_client_context * pcac;
    int caStatus = fetchClientContext (&pcac);
    if ( caStatus != ECA_NORMAL ) {
        return caStatus;
    }

    epicsGuard < epicsMutex > guard ( pcac->mutex );
    pcac->flush ( guard );

    return ECA_NORMAL;
}

int epicsStdCall ca_sg_array_get ( const CA_SYNC_GID  gid, chtype  type, arrayElementCount  count, chid  pChan, void *  pValue  )

friend

Definition at line 308 of file syncgrp.cpp.

{
    ca_client_context *pcac;

    int caStatus = fetchClientContext ( &pcac );
    if ( caStatus != ECA_NORMAL ) {
        return caStatus;
    }

    epicsGuard < epicsMutex > guard ( pcac->mutexRef() );
    CASG * const pcasg = pcac->lookupCASG ( guard, gid );
    if ( ! pcasg ) {
        return ECA_BADSYNCGRP;
    }

    try {
        pcasg->get ( guard, pChan, type,
            static_cast < unsigned > ( count ), pValue );
        return ECA_NORMAL;
    }
    catch ( cacChannel::badString & )
    {
        return ECA_BADSTR;
    }
    catch ( cacChannel::badType & )
    {
        return ECA_BADTYPE;
    }
    catch ( cacChannel::outOfBounds & )
    {
        return ECA_BADCOUNT;
    }
    catch ( cacChannel::noReadAccess & )
    {
        return ECA_NORDACCESS;
    }
    catch ( cacChannel::notConnected & )
    {
        return ECA_DISCONN;
    }
    catch ( cacChannel::unsupportedByService & )
    {
        return ECA_UNAVAILINSERV;
    }
    catch ( std::bad_alloc & )
    {
        return ECA_ALLOCMEM;
    }
    catch ( ... )
    {
        return ECA_INTERNAL;
    }
}

int epicsStdCall ca_sg_array_put ( const CA_SYNC_GID  gid, chtype  type, arrayElementCount  count, chid  pChan, const void *  pValue  )

friend

Definition at line 246 of file syncgrp.cpp.

{
    ca_client_context *pcac;

    int caStatus = fetchClientContext ( &pcac );
    if ( caStatus != ECA_NORMAL ) {
        return caStatus;
    }

    epicsGuard < epicsMutex > guard ( pcac->mutexRef() );
    CASG * const pcasg = pcac->lookupCASG ( guard, gid );
    if ( ! pcasg ) {
        return ECA_BADSYNCGRP;
    }

    try {
        pcasg->put ( guard, pChan, type,
            static_cast < unsigned > ( count ), pValue );
        return ECA_NORMAL;
    }
    catch ( cacChannel::badString & )
    {
        return ECA_BADSTR;
    }
    catch ( cacChannel::badType & )
    {
        return ECA_BADTYPE;
    }
    catch ( cacChannel::outOfBounds & )
    {
        return ECA_BADCOUNT;
    }
    catch ( cacChannel::noWriteAccess & )
    {
        return ECA_NOWTACCESS;
    }
    catch ( cacChannel::notConnected & )
    {
        return ECA_DISCONN;
    }
    catch ( cacChannel::unsupportedByService & )
    {
        return ECA_UNAVAILINSERV;
    }
    catch ( cacChannel::requestTimedOut & )
    {
        return ECA_TIMEOUT;
    }
    catch ( std::bad_alloc & )
    {
        return ECA_ALLOCMEM;
    }
    catch ( ... )
    {
        return ECA_INTERNAL;
    }
}

int epicsStdCall ca_sg_block ( const CA_SYNC_GID  gid, ca_real  timeout  )

friend

Definition at line 127 of file syncgrp.cpp.

{
    ca_client_context *pcac;
    int status = fetchClientContext ( &pcac );
    if ( status == ECA_NORMAL ) {
        CASG * pcasg;
        {
            epicsGuard < epicsMutex > guard ( pcac->mutex );
            pcasg = pcac->lookupCASG ( guard, gid );
            if ( pcasg ) {
                status = pcasg->block (
                    pcac->pCallbackGuard.get (), guard, timeout );
            }
            else {
                status = ECA_BADSYNCGRP;
            }
        }
        if ( pcasg ) {
            sync_group_reset ( *pcac, *pcasg );
        }
    }
    return status;
}

int epicsStdCall ca_sg_create ( CA_SYNC_GID *  pgid )

friend

Definition at line 24 of file syncgrp.cpp.

{
    ca_client_context * pcac;
    int caStatus;
    CASG * pcasg;

    caStatus = fetchClientContext ( &pcac );
    if ( caStatus != ECA_NORMAL ) {
        return caStatus;
    }

    try {
        epicsGuard < epicsMutex > guard ( pcac->mutexRef() );
        pcasg = new ( pcac->casgFreeList ) CASG ( guard, *pcac );
        *pgid = pcasg->getId ();
        return ECA_NORMAL;
    }
    catch ( std::bad_alloc & ) {
        return ECA_ALLOCMEM;
    }
    catch ( ... ) {
        return ECA_INTERNAL;
    }
}

int epicsStdCall ca_sg_delete ( const CA_SYNC_GID  gid )

friend

Definition at line 68 of file syncgrp.cpp.

{
    ca_client_context * pcac;
    int caStatus = fetchClientContext ( & pcac );
    if ( caStatus == ECA_NORMAL ) {
        if ( pcac->pCallbackGuard.get() &&
            pcac->createdByThread == epicsThreadGetIdSelf () ) {
          epicsGuard < epicsMutex > guard ( pcac->mutex );
          caStatus = ca_sync_group_destroy ( *pcac->pCallbackGuard.get(),
                                          guard, *pcac, gid );
        }
        else {
          //
          // we will definately stall out here if all of the
          // following are true
          //
          // o user creates non-preemtive mode client library context
          // o user doesnt periodically call a ca function
          // o user calls this function from an auxiillary thread
          //
          CallbackGuard cbGuard ( pcac->cbMutex );
          epicsGuard < epicsMutex > guard ( pcac->mutex );
          caStatus = ca_sync_group_destroy ( cbGuard, guard, *pcac, gid );
        }
    }
    return caStatus;
}

int epicsStdCall ca_sg_reset ( const CA_SYNC_GID  gid )

friend

Definition at line 155 of file syncgrp.cpp.

{
    ca_client_context *pcac;
    int caStatus = fetchClientContext (&pcac);
    if ( caStatus == ECA_NORMAL ) {
        CASG * pcasg;
        {
            epicsGuard < epicsMutex > guard ( pcac->mutex );
            pcasg = pcac->lookupCASG ( guard, gid );
        }
        if ( pcasg ) {
            sync_group_reset ( *pcac, *pcasg );
            caStatus = ECA_NORMAL;
        }
        else {
            caStatus = ECA_BADSYNCGRP;
        }
    }
    return caStatus;
}

int epicsStdCall ca_sg_test ( const CA_SYNC_GID  gid )

friend

Definition at line 202 of file syncgrp.cpp.

{
    ca_client_context * pcac;
    int caStatus = fetchClientContext ( &pcac );
    if ( caStatus == ECA_NORMAL ) {
        epicsGuard < epicsMutex > guard ( pcac->mutexRef() );
        CASG * pcasg = pcac->lookupCASG ( guard, gid );
        if ( pcasg ) {
            bool isComplete;
            if ( pcac->pCallbackGuard.get() &&
                pcac->createdByThread == epicsThreadGetIdSelf () ) {
              epicsGuard < epicsMutex > guard ( pcac->mutex );
              isComplete = pcasg->ioComplete ( *pcac->pCallbackGuard.get(), guard );
            }
            else {
              //
              // we will definately stall out here if all of the
              // following are true
              //
              // o user creates non-preemtive mode client library context
              // o user doesnt periodically call a ca function
              // o user calls this function from an auxiillary thread
              //
              CallbackGuard cbGuard ( pcac->cbMutex );
              epicsGuard < epicsMutex > guard ( pcac->mutex );
              isComplete = pcasg->ioComplete ( cbGuard, guard );
            }
            if ( isComplete ) {
                caStatus = ECA_IODONE;
            }
            else{
                caStatus = ECA_IOINPROGRESS;
            }
        }
        else {
            caStatus = ECA_BADSYNCGRP;
        }
    }
    return caStatus;
}

int ca_sync_group_destroy ( CallbackGuard &  cbGuard, epicsGuard< epicsMutex > &  guard, ca_client_context &  cac, const CA_SYNC_GID  gid  )

friend

Definition at line 49 of file syncgrp.cpp.

{
    int caStatus;
    CASG * pcasg = cac.lookupCASG ( guard, gid );
    if ( pcasg ) {
        pcasg->destructor ( cbGuard, guard );
        cac.casgFreeList.release ( pcasg );
        caStatus = ECA_NORMAL;
    }
    else {
        caStatus = ECA_BADSYNCGRP;
    }
    return caStatus;
}

void cacOnceFunc ( void *  )

friend

Definition at line 48 of file ca_client_context.cpp.

{
    caClientCallbackThreadId = epicsThreadPrivateCreate ();
    assert ( caClientCallbackThreadId );
    ca_client_context::pDefaultServiceInstallMutex = newEpicsMutex;
}

void sync_group_reset ( ca_client_context &  client, CASG &  sg  )

friend

Definition at line 96 of file syncgrp.cpp.

{
    if ( client.pCallbackGuard.get() &&
        client.createdByThread == epicsThreadGetIdSelf () ) {
        epicsGuard < epicsMutex > guard ( client.mutex );
        sg.reset ( *client.pCallbackGuard.get(), guard );
    }
    else {
        //
        // we will definately stall out here if all of the
        // following are true
        //
        // o user creates non-preemtive mode client library context
        // o user doesnt periodically call a ca function
        // o user calls this function from an auxiillary thread
        //
        CallbackGuard cbGuard ( client.cbMutex );
        epicsGuard < epicsMutex > guard ( client.mutex );
        sg.reset ( cbGuard, guard );
    }
}

Member Data Documentation

void exception epicsGuard< epicsMutex > int const char const char unsigned oldChannelNotify& ca_client_context::chan

Definition at line 314 of file oldAccess.h.

void exception epicsGuard< epicsMutex > int const char const char unsigned oldChannelNotify unsigned arrayElementCount ca_client_context::count

Definition at line 314 of file oldAccess.h.

void exception epicsGuard< epicsMutex > int const char const char unsigned ca_client_context::lineNo

Definition at line 311 of file oldAccess.h.

void exception epicsGuard< epicsMutex > int const char const char unsigned oldChannelNotify unsigned arrayElementCount unsigned ca_client_context::op

Definition at line 314 of file oldAccess.h.

void exception epicsGuard< epicsMutex > int const char * ca_client_context::pContext

Definition at line 311 of file oldAccess.h.

void exception epicsGuard< epicsMutex > int const char const char * ca_client_context::pFileName

Definition at line 311 of file oldAccess.h.

void exception epicsGuard< epicsMutex > int ca_client_context::status

Definition at line 311 of file oldAccess.h.

void exception epicsGuard< epicsMutex > int const char const char unsigned oldChannelNotify unsigned ca_client_context::type

Definition at line 314 of file oldAccess.h.

---

The documentation for this struct was generated from the following files:

• modules/ca/src/client/oldAccess.h
• modules/ca/src/client/ca_client_context.cpp