bsProxyThread.c File Reference

BotSense bsProxy service threads. More...

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include "rnr/rnrconfig.h"
#include "rnr/log.h"
#include "rnr/new.h"
#include "rnr/hash.h"
#include "rnr/dlistvoid.h"
#include "rnr/path.h"
#include "botsense/BotSense.h"
#include "botsense/libBotSense.h"
#include "botsense/bsProxyMsgs.h"
#include "bsProxy.h"

Go to the source code of this file.

Macros
#define	BSPROXY_TH_HASH_MIN   8
	minimum hash table size
#define	BSPROXY_TH_HASH_MAX   256
	maximum hash table size
#define	BSPROXY_TH_MAX_QUEUE_SIZE   8
	request queue maximum depth
#define	BSPROXY_TH_SERVER_URI   "#SERVER"
	server "URI"
#define	BSPROXY_TH_LOG_ERROR(devuri, ecode, efmt, ...)
	Log Proxy Server Thread Error. More...

Functions
static int	ThQReqCmp (const void *pData1, const void *pData2)
	Queue callback to compare two queue entries. More...
static void	ThQReqDelete (void *pData)
	Queue callback to delete queue entry. More...
static BsProxyThCtl_T *	ThCtlBlkNew (const char *sDevUri)
	Allocate new service thread control block. More...
static void	ThCtlBlkDelete (BsProxyThCtl_T *pThCtl)
	Delete service thread control block. More...
static void	ThGlobalLock ()
	Lock global mutual exclusion.
static void	ThGlobalUnlock ()
	Unlock global mutual exclusion.
static bool_t	ThGlobalTryLock ()
	Try to lock global mutual exclusion. More...
static void	ThSyncLock (BsProxyThCtl_T *pThCtl)
	Lock service thread's mutual exclusion. More...
static void	ThSyncUnlock (BsProxyThCtl_T *pThCtl)
	Unlock service thread's mutual exclusion. More...
static void	ThSyncSignal (BsProxyThCtl_T *pThCtl)
	Signal service thread's condition. More...
static void	ThSyncWait (BsProxyThCtl_T *pThCtl)
	Wait on service thread's condition. More...
static void	ThHashDeleteData (void *sDevUri, void *pThCtl)
	Delete hash node data callback. More...
static int	ThHashAdd (const char *sDevUri, BsProxyThCtl_T *pThCtl)
	Add the module data to the i/f module hash table. More...
static void	ThHashDelete (BsProxyThCtl_T *pThCtl)
	Remove and delete the module data from the i/f module hash table. More...
static BsProxyThCtl_T *	ThHashGetCtl (const char *sDevUri)
	Get the interface module's i/f from the module hash table. More...
static void	ThSyncRun (BsProxyThCtl_T *pThCtl)
	Command service thread to run. More...
static void	ThSyncExit (BsProxyThCtl_T *pThCtl)
	Command service thread to exit. More...
static void	ThSyncWaitForRun (BsProxyThCtl_T *pThCtl)
	Wait indefinitely until state change. More...
static int	ThDevRequest (BsProxyClientHnd_T hndClient, BsVConnHnd_T hndVConn, BsTid_T uTid, BsMsgId_T uMsgId, byte_t bufReq[], size_t uReqLen)
	Device service thread request handler. More...
static void *	ThServiceThread (void *pThArg)
	The service thread. More...
BsProxyThReq_T *	ThReqNew (BsProxyClientHnd_T hndClient, BsVConnHnd_T hndVConn, BsTid_T uTid, BsMsgId_T uMsgId, byte_t bufReq[], size_t uReqLen)
	Allocate and initalized a new service thread request. More...
void	ThReqDelete (BsProxyThReq_T *pThReq)
	Delete service thread request. More...
int	ThQueue (BsProxyThCtl_T *pThCtl, BsProxyClientHnd_T hndClient, BsVConnHnd_T hndVConn, BsTid_T uTid, BsMsgId_T uMsgId, byte_t bufReq[], size_t uReqLen)
	Queue a request for the given service thread. More...
BsProxyThReq_T *	ThDequeue (BsProxyThCtl_T *pThCtl)
	Dequeue a request for the given service thread. More...
void	ThOneTimeInit ()
	The service thread one-time global initialization.
char *	ThNewDevUri (const char *sDevName)
	Convert the device name to a quasi Uniform Resource Id. More...
BsProxyThCtl_T *	ThCreateDevThread (const char *sDevUri)
	Create a device service thread. More...
BsProxyThCtl_T *	ThCreateServerThread ()
	Create the special server service thread. More...
void	ThDestroyThread (BsProxyThCtl_T *pThCtl)
	Destroy service thread. More...

Variables
static pthread_mutex_t	BsThGlobalMutex
	bsProxy module operations mutex
static hash_t *	BsThHashTbl
	proxied device hash table

Detailed Description

BotSense bsProxy service threads.

LastChangedDate

2010-08-20 11:36:38 -0600 (Fri, 20 Aug 2010)

Rev

568

A Sevice thread provides a separate execution context to service client request-response exchanges. There are two types of service threads:

Server Thread	1 thread to service server-terminated requests.
Device Thread	N device threads, one attached to each URI unique, opened device.

Author

Robin Knight (robin.nosp@m..kni.nosp@m.ght@r.nosp@m.oadn.nosp@m.arrow.nosp@m.s.co.nosp@m.m)

Copyright

© 2007-2017. RoadNarrows LLC.
http://www.roadnarrows.com
All Rights Reserved

Definition in file bsProxyThread.c.

Macro Definition Documentation

#define BSPROXY_TH_LOG_ERROR	(		devuri,
			ecode,
			efmt,
			...
	)

Value:

LOGERROR("%s: Service Thread \"%s\": %s(ecode=%d): " efmt, \
      ServerHasName(), devuri, \
      bsStrError(ecode), (ecode>=0? ecode: -ecode), \
      ##__VA_ARGS__)

Log Proxy Server Thread Error.

Parameters

devuri	Device URI string.
ecode

Definition at line 101 of file bsProxyThread.c.

Referenced by ThCreateServerThread(), ThHashAdd(), ThQueue(), and ThServiceThread().

Function Documentation

BsProxyThCtl_T* ThCreateDevThread

(

const char *

sDevUri

)

Create a device service thread.

The actual thread is only created if it does not already exists. The internal reference count is incremented to keep track of the users of this thread.

Execution Context:

Calling thread.

Parameters

sDevUri

Device URI.

Returns

On success, returns the service thread control block. On failure, NULL is returned.

Definition at line 756 of file bsProxyThread.c.

References BsProxyThStateInit, _bsproxy_th_ctl::m_eState, _bsproxy_th_ctl::m_fnRequest, _bsproxy_th_ctl::m_sDevUri, _bsproxy_th_ctl::m_thread, _bsproxy_th_ctl::m_uRefCnt, ThCtlBlkDelete(), ThCtlBlkNew(), ThDevRequest(), ThGlobalLock(), ThGlobalUnlock(), ThHashAdd(), ThHashDelete(), ThHashGetCtl(), ThServiceThread(), and ThSyncRun().

Referenced by ClientSetTraceState(), and VConnOpenDev().

{
  BsProxyThCtl_T *pThCtl;
  int             rc;

  // lock global mutex
  ThGlobalLock();

  //
  // Device thread already exists. 
  //
  if( (pThCtl = ThHashGetCtl(sDevUri)) != NULL )
  {
    pThCtl->m_uRefCnt++;
    LOGDIAG1("Service Thread \"%s\" attached (refcnt=%u).",
        pThCtl->m_sDevUri, pThCtl->m_uRefCnt);
  }

  //
  // Create new device thread.
  //
  else
  {
    //
    // Create a new thread control block.
    //
    pThCtl = ThCtlBlkNew(sDevUri);

    pThCtl->m_fnRequest = ThDevRequest;       // device request handler
    pThCtl->m_uRefCnt   = 1;                  // thread reference count
    pThCtl->m_eState    = BsProxyThStateInit; // control is (mostly) initialized

    //
    // Add thread control to thread hash table
    //
    if( (rc = ThHashAdd(sDevUri, pThCtl)) < 0 )
    {
      LOGERROR("\"%s\": Failed to add thread control to hash table.", sDevUri);
      ThCtlBlkDelete(pThCtl);
      pThCtl = NULL;
    }

    //
    // Start the device service thread. The thread will block until the run
    // state is set this context.
    //
    else if( pthread_create(&pThCtl->m_thread, NULL, ThServiceThread,
                            (void *)pThCtl) )
    {
      LOGSYSERROR("pthread_create(\"%s\")", sDevUri);
      ThHashDelete(pThCtl);
      pThCtl = NULL;
    }

    //
    // Signal the thread to run.
    //
    else
    {
      ThSyncRun(pThCtl);
    }
  }

  // unlock thread mutex
  ThGlobalUnlock();

  return pThCtl;
}

BsProxyThCtl_T* ThCreateServerThread

(

)

Create the special server service thread.

There is only one server service thread per server. The server thread processes all server terminated requests.

Execution Context:

Calling thread.

Returns

On success, returns the service thread control block. On failure, NULL is returned.

Definition at line 837 of file bsProxyThread.c.

References BS_ECODE_INTERNAL, BSPROXY_TH_LOG_ERROR, BSPROXY_TH_SERVER_URI, BsProxyThStateInit, _bsproxy_th_ctl::m_eState, _bsproxy_th_ctl::m_fnRequest, _bsproxy_th_ctl::m_thread, _bsproxy_th_ctl::m_uRefCnt, ServerRequest(), ThCtlBlkDelete(), ThCtlBlkNew(), ThGlobalLock(), ThGlobalUnlock(), ThHashAdd(), ThHashDelete(), ThHashGetCtl(), ThServiceThread(), and ThSyncRun().

Referenced by ClientSetTraceState(), and VConnOpenServer().

{
  char           *sDevUri;
  BsProxyThCtl_T *pThCtl;
  int             rc;

  // Server URI
  sDevUri = new_strdup(BSPROXY_TH_SERVER_URI);

  // lock global mutex
  ThGlobalLock();

  //
  // There should only be one server thread.
  //
  if( (pThCtl = ThHashGetCtl(sDevUri)) != NULL )
  {
    BSPROXY_TH_LOG_ERROR(sDevUri, BS_ECODE_INTERNAL,
        "Server service thread already exists.");
  }

  //
  // Create new device thread.
  //
  else
  {
    //
    // Create a new thread control block.
    //
    pThCtl = ThCtlBlkNew(sDevUri);

    pThCtl->m_fnRequest = ServerRequest;      // server request handler
    pThCtl->m_uRefCnt   = 1;                  // thread reference count
    pThCtl->m_eState    = BsProxyThStateInit; // control is (mostly) initialized

    //
    // Add thread control to thread hash table
    //
    if( (rc = ThHashAdd(sDevUri, pThCtl)) < 0 )
    {
      LOGERROR("\"%s\": Failed to add thread control to hash table.", sDevUri);
      ThCtlBlkDelete(pThCtl);
      pThCtl = NULL;
    }

    //
    // Start the device service thread. The thread will block until the run
    // state is set this context.
    //
    else if( pthread_create(&pThCtl->m_thread, NULL, ThServiceThread,
                            (void *)pThCtl) )
    {
      LOGSYSERROR("pthread_create(\"%s\")", sDevUri);
      ThHashDelete(pThCtl);
      pThCtl = NULL;
    }

    //
    // Signal the thread to run.
    //
    else
    {
      ThSyncRun(pThCtl);
    }
  }

  // unlock global mutex
  ThGlobalUnlock();

  return pThCtl;
}

static void ThCtlBlkDelete ( BsProxyThCtl_T *  pThCtl )

static

Delete service thread control block.

Parameters

pThCtl

Pointer to thread control block.

Definition at line 173 of file bsProxyThread.c.

References _bsproxy_th_ctl::m_condSync, _bsproxy_th_ctl::m_mutexSync, _bsproxy_th_ctl::m_queue, and _bsproxy_th_ctl::m_sDevUri.

Referenced by ThCreateDevThread(), ThCreateServerThread(), and ThHashDeleteData().

{
  if( pThCtl != NULL )
  {
    // delete uri
    delete((char *)pThCtl->m_sDevUri);

    // delete request queue
    DListVoidDelete(pThCtl->m_queue);

    // destroy condition
    pthread_cond_destroy(&pThCtl->m_condSync);

    // destroy mutex
    pthread_mutex_destroy(&pThCtl->m_mutexSync);

    // delete self
    delete(pThCtl);
  }
}

static BsProxyThCtl_T* ThCtlBlkNew ( const char *  sDevUri )

static

Allocate new service thread control block.

Parameters

sDevUri

Device URI.

Returns

Pointer to allocated thread control block.

Definition at line 150 of file bsProxyThread.c.

References BsProxyThStateUninit, _bsproxy_th_ctl::m_condSync, _bsproxy_th_ctl::m_eState, _bsproxy_th_ctl::m_mutexSync, _bsproxy_th_ctl::m_queue, _bsproxy_th_ctl::m_sDevUri, _bsproxy_th_ctl::m_uRefCnt, ThQReqCmp(), and ThQReqDelete().

Referenced by ThCreateDevThread(), and ThCreateServerThread().

{
  BsProxyThCtl_T *pThCtl = NEW(BsProxyThCtl_T);

  pThCtl->m_sDevUri = new_strdup(sDevUri);
  pThCtl->m_uRefCnt = 0;
  pThCtl->m_eState  = BsProxyThStateUninit;
  pThCtl->m_queue   = DListVoidNew(ThQReqCmp, ThQReqDelete);

  // create mutex
  pthread_mutex_init(&pThCtl->m_mutexSync, NULL);

  // create condition
  pthread_cond_init(&pThCtl->m_condSync, NULL);

  return pThCtl;
}

BsProxyThReq_T* ThDequeue

(

BsProxyThCtl_T *

pThCtl

)

Dequeue a request for the given service thread.

The service thread will block if no queued request is present.

Execution Context:

Service thread.

Returns

On success, returns removed request at the front of the queue.
On failure, NULL is returned.

Definition at line 675 of file bsProxyThread.c.

References BsProxyThStateRunning, _bsproxy_th_ctl::m_eState, _bsproxy_th_ctl::m_queue, ThSyncLock(), ThSyncUnlock(), and ThSyncWait().

Referenced by ClientSetTraceState(), and ThServiceThread().

{
  BsProxyThReq_T  *pThReq;

  // lock thread and queue
  ThSyncLock(pThCtl);

  //
  // Block waiting for queued request or state change event.
  //
  while( (pThCtl->m_eState == BsProxyThStateRunning) &&
         (DListVoidCount(pThCtl->m_queue) == 0) )
  {
    // Release mutex, block on conditional variable, auto-lock mutex on return.
    ThSyncWait(pThCtl);
  }

  if( pThCtl->m_eState == BsProxyThStateRunning )
  {
    pThReq = (BsProxyThReq_T *)DListVoidDequeue(pThCtl->m_queue);
  }
  else
  {
    pThReq = NULL;
  }

  // unlock thread and queue
  ThSyncUnlock(pThCtl);

  return pThReq;
}

void ThDestroyThread

(

BsProxyThCtl_T *

pThCtl

)

Destroy service thread.

The thread's reference count is decremented. If the count is zero, then the thread is actually destroyed with all queued requests deleted. The calling thread is suspended until the target service thread terminates.

Execution Context:

Calling thread.

Parameters

pThCtl

Service thread control block.

Definition at line 921 of file bsProxyThread.c.

References _bsproxy_th_ctl::m_sDevUri, _bsproxy_th_ctl::m_thread, _bsproxy_th_ctl::m_uRefCnt, ThGlobalLock(), ThGlobalUnlock(), ThHashDelete(), and ThSyncExit().

Referenced by ClientSetTraceState(), VConnClose(), and VConnOpenDev().

{
  if( pThCtl == NULL )
  {
    return;
  }

  // lock global mutex
  ThGlobalLock();

  // do not destroy the thread since there exists users of this thread
  if( pThCtl->m_uRefCnt > 0 )
  {
    pThCtl->m_uRefCnt--;
  }

  // thread is not being used anymore - destroy
  if( pThCtl->m_uRefCnt == 0 )
  {
    // signal thread of exit state change
    ThSyncExit(pThCtl);

    // wait for thread to terminate
    pthread_join(pThCtl->m_thread, NULL);

    // delete the thread hash entry's control block (including its queue)
    ThHashDelete(pThCtl);
  }

  else
  {
    LOGDIAG1("Service Thread \"%s\" detached (refcnt=%u).",
        pThCtl->m_sDevUri, pThCtl->m_uRefCnt);
  }

  // unlock global mutex
  ThGlobalUnlock();
}

static int ThDevRequest ( BsProxyClientHnd_T  hndClient, BsVConnHnd_T  hndVConn, BsTid_T  uTid, BsMsgId_T  uMsgId, byte_t  bufReq[], size_t  uReqLen  )

static

Device service thread request handler.

Execution Context:

Device service thread.

Parameters

hndClient

Definition at line 462 of file bsProxyThread.c.

References BS_ECODE_NO_VCONN, BSPROXY_LOG_ERROR, BSPROXY_SEND_ERROR_RSP, BsProxyModIF_T::m_fnModRequest, BsProxyVConn_T::m_pModIF, VConnAcquire(), and VConnRelease().

Referenced by ThCreateDevThread().

{
  BsProxyVConn_T *pVConn;
  int             rc;

  //
  // Acquire virtual connection.
  //
  if( (pVConn = VConnAcquire(hndVConn)) != NULL )
  {
    //
    // Call the interface module' specific request handler.
    // The module is responsible for sending a response back regardless if the
    // request is a success or a failure.
    //
    rc = pVConn->m_pModIF->m_fnModRequest(hndVConn, uTid, uMsgId, bufReq,
                                          uReqLen);

    // release virtual connection
    VConnRelease(hndVConn); 

    // error
    if( rc < 0 )
    {
      BSPROXY_LOG_ERROR(hndClient, rc, "Request failed.");
    }
  }

  else
  {
    BSPROXY_SEND_ERROR_RSP(hndClient, hndVConn, uTid, BS_ECODE_NO_VCONN,
        "VConn=%d", hndVConn);
    rc = -BS_ECODE_NO_VCONN;
  }

  return rc;
}

static bool_t ThGlobalTryLock ( )

inlinestatic

Try to lock global mutual exclusion.

Returns

Returns true if lock is acquired. Otherwise returns false if mutex already locked.

Definition at line 234 of file bsProxyThread.c.

References BsThGlobalMutex.

{
  return pthread_mutex_trylock(&BsThGlobalMutex) == 0? true: false;
}

static int ThHashAdd ( const char *  sDevUri, BsProxyThCtl_T *  pThCtl  )

static

Add the module data to the i/f module hash table.

Parameters

sDevUri	Allocated Proxied device hash table key.
pThCtl	Allocated service thread control.

Returns

On success, BS_OK is returned.
On error, the appropriate < 0 negated BotSense Error Code is returned.

Definition at line 334 of file bsProxyThread.c.

References BS_ECODE_NO_RSRC, BS_OK, BSPROXY_TH_LOG_ERROR, BsThHashTbl, and ThHashDeleteData().

Referenced by ThCreateDevThread(), and ThCreateServerThread().

{
  char *sKey = new_strdup(sDevUri);
  int   rc;

  // insert into hash table, automatically allocating hnode_t
  if( !hash_insert(BsThHashTbl, sKey, pThCtl) )
  {
    rc = -BS_ECODE_NO_RSRC;
    BSPROXY_TH_LOG_ERROR(sDevUri, rc, "hash_insert(%s,...) failed", sKey);
    ThHashDeleteData(sKey, pThCtl);
    return rc;
  }

  return BS_OK;
}

static void ThHashDelete ( BsProxyThCtl_T *  pThCtl )

static

Remove and delete the module data from the i/f module hash table.

Parameters

pThCtl

Allocated service thread control.

Returns

On success, BS_OK is returned.
On error, the appropriate < 0 negated BotSense Error Code is returned.

Definition at line 358 of file bsProxyThread.c.

References BsThHashTbl, and _bsproxy_th_ctl::m_sDevUri.

Referenced by ThCreateDevThread(), ThCreateServerThread(), and ThDestroyThread().

{
  hnode_t *pNode;

  if( (pThCtl != NULL) && 
      ((pNode = hash_lookup(BsThHashTbl, pThCtl->m_sDevUri)) != NULL) )
  {
    hash_node_delete(BsThHashTbl, pNode);
  }
}

static void ThHashDeleteData ( void *  sDevUri, void *  pThCtl  )

static

Delete hash node data callback.

Both the key and value are dynamically allocated.

Parameters

sDevUri	Proxied device hash table key.
pThCtl	Service thread control.

Definition at line 320 of file bsProxyThread.c.

References ThCtlBlkDelete().

Referenced by ThHashAdd(), and ThOneTimeInit().

{
  delete(sDevUri);
  ThCtlBlkDelete(pThCtl);
}

static BsProxyThCtl_T* ThHashGetCtl ( const char *  sDevUri )

static

Get the interface module's i/f from the module hash table.

Parameters

sDevUri

Proxied device hash table key.

Returns

On success, returns pointer to the associated thread control block. On failure, returns NULL.

Definition at line 378 of file bsProxyThread.c.

References BsThHashTbl.

Referenced by ThCreateDevThread(), and ThCreateServerThread().

{
  hnode_t       *pNode;

  if( (pNode = hash_lookup(BsThHashTbl, sDevUri)) == NULL )
  {
     return NULL;
  }
  else
  {
    return (BsProxyThCtl_T *)hnode_get(pNode);
  }
}

char* ThNewDevUri

(

const char *

sDevName

)

Convert the device name to a quasi Uniform Resource Id.

Parameters

sDevName

Device path name.

Returns

On success, an allocated, canonical device path name is returned.
On failure, NULL is returned.

Definition at line 737 of file bsProxyThread.c.

Referenced by ClientSetTraceState(), and VConnOpenDev().

{
  return NewSearchPathCanonicalized(sDevName);
}

static int ThQReqCmp ( const void *  pData1, const void *  pData2  )

static

Queue callback to compare two queue entries.

Parameters

pData1	Pointer to queue entry 1.
pData2	Pointer to queue entry 2.

Returns

Returns < 0, 0, or > 0 if data 1 is less than, equal to, or greater than data2, respectively.

Definition at line 121 of file bsProxyThread.c.

References BSPROXY_MAKE_MSGUID, _bsproxy_th_req::m_hndVConn, and _bsproxy_th_req::m_uMsgId.

Referenced by ThCtlBlkNew().

{
  BsProxyThReq_T *pThReq1 = (BsProxyThReq_T *)pData1;
  BsProxyThReq_T *pThReq2 = (BsProxyThReq_T *)pData2;
  BsMsgUid_T      uid1 = BSPROXY_MAKE_MSGUID(pThReq1->m_hndVConn,
                                             pThReq1->m_uMsgId);
  BsMsgUid_T      uid2 = BSPROXY_MAKE_MSGUID(pThReq2->m_hndVConn,
                                             pThReq2->m_uMsgId);

  return (int)uid1 - (int)uid2;
}

static void ThQReqDelete ( void *  pData )

static

Queue callback to delete queue entry.

Parameters

pData

Pointer to queue entry.

Definition at line 138 of file bsProxyThread.c.

References ThReqDelete().

Referenced by ThCtlBlkNew().

{
  ThReqDelete((BsProxyThReq_T *)pData);
}

int ThQueue	(	BsProxyThCtl_T *	pThCtl,
		BsProxyClientHnd_T	hndClient,
		BsVConnHnd_T	hndVConn,
		BsTid_T	uTid,
		BsMsgId_T	uMsgId,
		byte_t	bufReq[],
		size_t	uReqLen
	)

Queue a request for the given service thread.

Execution Context:

Calling thread.

Parameters

pThCtl	Service thread control block.
hndClient	Client handle.
hndVConn	Virtual connection handle.
uTid	Request-Response transaction id.
uMsgId	Request message id.
bufReq	Allocated packed request message body.
uReqLen	Length of request in buffer (number of bytes).

Returns

On success, BS_OK is returned.
On error, the appropriate < 0 negated BotSense Error Code is returned.

Definition at line 626 of file bsProxyThread.c.

References BS_ECODE_NO_RSRC, BS_OK, BSPROXY_TH_LOG_ERROR, BSPROXY_TH_MAX_QUEUE_SIZE, _bsproxy_th_ctl::m_queue, _bsproxy_th_ctl::m_sDevUri, ServerHasName(), ThReqNew(), ThSyncLock(), ThSyncSignal(), and ThSyncUnlock().

Referenced by BsProxyDispatch(), and ClientSetTraceState().

{
  BsProxyThReq_T *pThReq;
  int             rc;

  // lock thread and queue
  ThSyncLock(pThCtl);

  //
  // Queue request on thread's message queue.
  //
  if( DListVoidCount(pThCtl->m_queue) < BSPROXY_TH_MAX_QUEUE_SIZE )
  {
    pThReq = ThReqNew(hndClient, hndVConn, uTid, uMsgId, bufReq, uReqLen);
    DListVoidQueue(pThCtl->m_queue, pThReq);
    ThSyncSignal(pThCtl);
    LOGDIAG3("%s: Service Thread \"%s\": queue depth=%u.",
      ServerHasName(), pThCtl->m_sDevUri, DListVoidCount(pThCtl->m_queue)); 
    rc = BS_OK;
  }
  else
  {
    rc = -BS_ECODE_NO_RSRC;
    BSPROXY_TH_LOG_ERROR(pThCtl->m_sDevUri, rc, "Queue overflow.");
  }

  // unlock thread and queue
  ThSyncUnlock(pThCtl);

  return rc;
}

void ThReqDelete

(

BsProxyThReq_T *

pThReq

)

Delete service thread request.

Parameters

pThReq

Service thread request.

Definition at line 601 of file bsProxyThread.c.

References _bsproxy_th_req::m_bufReq.

Referenced by ClientSetTraceState(), ThQReqDelete(), and ThServiceThread().

{
  if( pThReq != NULL )
  {
    delete(pThReq->m_bufReq);
    delete(pThReq);
  }
}

BsProxyThReq_T* ThReqNew	(	BsProxyClientHnd_T	hndClient,
		BsVConnHnd_T	hndVConn,
		BsTid_T	uTid,
		BsMsgId_T	uMsgId,
		byte_t	bufReq[],
		size_t	uReqLen
	)

Allocate and initalized a new service thread request.

Parameters

hndClient	Client handle.
hndVConn	Virtual connection handle.
uTid	Request-Response transaction id.
uMsgId	Request message id.
bufReq	Allocated packed request message body.
uReqLen	Length of request in buffer (number of bytes).

Returns

Pointer to allocated request.

Definition at line 577 of file bsProxyThread.c.

References _bsproxy_th_req::m_bufReq, _bsproxy_th_req::m_hndClient, _bsproxy_th_req::m_hndVConn, _bsproxy_th_req::m_uMsgId, _bsproxy_th_req::m_uReqLen, and _bsproxy_th_req::m_uTid.

Referenced by ClientSetTraceState(), and ThQueue().

{
  BsProxyThReq_T *pThReq = NEW(BsProxyThReq_T);

  pThReq->m_hndClient = hndClient;
  pThReq->m_hndVConn  = hndVConn;
  pThReq->m_uTid      = uTid;
  pThReq->m_uMsgId    = uMsgId;
  pThReq->m_bufReq    = bufReq;
  pThReq->m_uReqLen   = uReqLen;

  return pThReq;
}

static void* ThServiceThread ( void *  pThArg )

static

The service thread.

Parameters

pThArg

Thread argument.

Returns

Returns NULL on thread exit.

Definition at line 512 of file bsProxyThread.c.

References BS_ECODE_NO_EXEC, BSPROXY_TH_LOG_ERROR, BsProxyThStateExit, _bsproxy_th_req::m_bufReq, _bsproxy_th_ctl::m_eState, _bsproxy_th_ctl::m_fnRequest, _bsproxy_th_req::m_hndClient, _bsproxy_th_req::m_hndVConn, _bsproxy_th_ctl::m_sDevUri, _bsproxy_th_req::m_uMsgId, _bsproxy_th_req::m_uReqLen, _bsproxy_th_req::m_uTid, ThDequeue(), ThReqDelete(), and ThSyncWaitForRun().

Referenced by ThCreateDevThread(), and ThCreateServerThread().

{
  BsProxyThCtl_T *pThCtl = (BsProxyThCtl_T *)pThArg;
  BsProxyThReq_T *pThReq;
  int             rc;

  LOGDIAG1("Service Thread \"%s\" created.", pThCtl->m_sDevUri);

  ThSyncWaitForRun(pThCtl);

  //
  // Wait for any queue message or thread state change.
  //
  while( (pThReq = ThDequeue(pThCtl)) )
  {
    // exit thread
    if( pThCtl->m_eState == BsProxyThStateExit )
    {
      break;
    }
    // nothing on queue
    else if( pThReq == NULL )
    {
      BSPROXY_TH_LOG_ERROR(pThCtl->m_sDevUri, BS_ECODE_NO_EXEC,
          "No request on queue.");
    }
    // service request then destroy
    else
    {
      rc = pThCtl->m_fnRequest(pThReq->m_hndClient,
                               pThReq->m_hndVConn,
                               pThReq->m_uTid,
                               pThReq->m_uMsgId,
                               pThReq->m_bufReq,
                               pThReq->m_uReqLen);
      ThReqDelete(pThReq);
    }
  }

  LOGDIAG1("Service Thread \"%s\" destroyed.", pThCtl->m_sDevUri);

  return NULL;
}

static void ThSyncExit ( BsProxyThCtl_T *  pThCtl )

static

Command service thread to exit.

Execution Context:

Calling thread.

Parameters

pThCtl

Service thread control block.

Definition at line 421 of file bsProxyThread.c.

References BsProxyThStateExit, _bsproxy_th_ctl::m_eState, ThSyncLock(), ThSyncSignal(), and ThSyncUnlock().

Referenced by ThDestroyThread().

{
  ThSyncLock(pThCtl);
  pThCtl->m_eState = BsProxyThStateExit;
  ThSyncSignal(pThCtl);
  ThSyncUnlock(pThCtl);
}

static void ThSyncLock ( BsProxyThCtl_T *  pThCtl )

inlinestatic

Lock service thread's mutual exclusion.

Parameters

pThCtl

Service thread control.

Definition at line 244 of file bsProxyThread.c.

References _bsproxy_th_ctl::m_mutexSync, and _bsproxy_th_ctl::m_sDevUri.

Referenced by ThDequeue(), ThQueue(), ThSyncExit(), ThSyncRun(), and ThSyncWaitForRun().

{
  int rc;

  if( (rc = pthread_mutex_lock(&pThCtl->m_mutexSync)) != 0 )
  { 
    errno = rc;
    LOGSYSERROR("Service Thread \"%s\": pthread_mutex_lock()",
        pThCtl->m_sDevUri);
  }
}

static void ThSyncRun ( BsProxyThCtl_T *  pThCtl )

static

Command service thread to run.

Parameters

pThCtl

Service thread control block.

Execution Context:

Calling thread.

Definition at line 405 of file bsProxyThread.c.

References BsProxyThStateRunning, _bsproxy_th_ctl::m_eState, ThSyncLock(), ThSyncSignal(), and ThSyncUnlock().

Referenced by ThCreateDevThread(), and ThCreateServerThread().

{
  ThSyncLock(pThCtl);
  pThCtl->m_eState = BsProxyThStateRunning;
  ThSyncSignal(pThCtl);
  ThSyncUnlock(pThCtl);
}

static void ThSyncSignal ( BsProxyThCtl_T *  pThCtl )

inlinestatic

Signal service thread's condition.

Parameters

pThCtl

Service thread control.

Definition at line 278 of file bsProxyThread.c.

References _bsproxy_th_ctl::m_condSync, and _bsproxy_th_ctl::m_sDevUri.

Referenced by ThQueue(), ThSyncExit(), and ThSyncRun().

{
  int rc;

  if( (rc = pthread_cond_signal(&pThCtl->m_condSync)) != 0 )
  { 
    errno = rc;
    LOGSYSERROR("Service Thread \"%s\": pthread_cond_signal()",
        pThCtl->m_sDevUri);
  }
}

static void ThSyncUnlock ( BsProxyThCtl_T *  pThCtl )

inlinestatic

Unlock service thread's mutual exclusion.

Parameters

pThCtl

Service thread control.

Definition at line 261 of file bsProxyThread.c.

References _bsproxy_th_ctl::m_mutexSync, and _bsproxy_th_ctl::m_sDevUri.

Referenced by ThDequeue(), ThQueue(), ThSyncExit(), ThSyncRun(), and ThSyncWaitForRun().

{
  int rc;

  if( (rc = pthread_mutex_unlock(&pThCtl->m_mutexSync)) != 0 )
  { 
    errno = rc;
    LOGSYSERROR("Service Thread \"%s\": pthread_mutex_unlock()",
        pThCtl->m_sDevUri);
  }
}

static void ThSyncWait ( BsProxyThCtl_T *  pThCtl )

inlinestatic

Wait on service thread's condition.

Parameters

pThCtl

Service thread control.

Definition at line 295 of file bsProxyThread.c.

References _bsproxy_th_ctl::m_condSync, _bsproxy_th_ctl::m_mutexSync, and _bsproxy_th_ctl::m_sDevUri.

Referenced by ThDequeue(), and ThSyncWaitForRun().

{
  int rc;

  if( (rc = pthread_cond_wait(&pThCtl->m_condSync, &pThCtl->m_mutexSync)) != 0 )
  { 
    errno = rc;
    LOGSYSERROR("Service Thread \"%s\": pthread_cond_wait()",
        pThCtl->m_sDevUri);
  }
}

static void ThSyncWaitForRun ( BsProxyThCtl_T *  pThCtl )

static

Wait indefinitely until state change.

Execution Context:

Service thread.

Parameters

pThCtl

Service thread control block.

Definition at line 437 of file bsProxyThread.c.

References BsProxyThStateInit, _bsproxy_th_ctl::m_eState, ThSyncLock(), ThSyncUnlock(), and ThSyncWait().

Referenced by ThServiceThread().

{
  ThSyncLock(pThCtl);
  while( pThCtl->m_eState == BsProxyThStateInit )
  {
    ThSyncWait(pThCtl);
  }
  ThSyncUnlock(pThCtl);
}