/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
** prcountr.c -- NSPR Instrumentation Counters
**
** Implement the interface defined in prcountr.h
**
** Design Notes:
**
** The Counter Facility (CF) has a single anchor: qNameList.
** The anchor is a PRCList. qNameList is a list of links in QName
** structures. From qNameList any QName structure and its
** associated RName structure can be located.
**
** For each QName, a list of RName structures is anchored at
** rnLink in the QName structure.
**
** The counter itself is embedded in the RName structure.
**
** For manipulating the counter database, single lock is used to
** protect the entire list: counterLock.
**
** A PRCounterHandle, defined in prcountr.h, is really a pointer
** to a RName structure. References by PRCounterHandle are
** dead-reconed to the RName structure. The PRCounterHandle is
** "overloaded" for traversing the QName structures; only the
** function PR_FindNextQnameHandle() uses this overloading.
**
**
** ToDo (lth): decide on how to lock or atomically update
** individual counters. Candidates are: the global lock; a lock
** per RName structure; Atomic operations (Note that there are
** not adaquate atomic operations (yet) to achieve this goal). At
** this writing (6/19/98) , the update of the counter variable in
** a QName structure is unprotected.
**
*/

#include "prcountr.h"
#include "prclist.h"
#include "prlock.h"
#include "prlog.h"
#include "prmem.h"
#include <string.h>

/*
**
*/
typedef struct QName {
  PRCList link;
  PRCList rNameList;
  char name[PRCOUNTER_NAME_MAX + 1];
} QName;

/*
**
*/
typedef struct RName {
  PRCList link;
  QName* qName;
  PRLock* lock;
  volatile PRUint32 counter;
  char name[PRCOUNTER_NAME_MAX + 1];
  char desc[PRCOUNTER_DESC_MAX + 1];
} RName;

/*
** Define the Counter Facility database
*/
static PRLock* counterLock;
static PRCList qNameList;
static PRLogModuleInfo* lm;

/*
** _PR_CounterInitialize() -- Initialize the Counter Facility
**
*/
static void _PR_CounterInitialize(void) {
  /*
  ** This function should be called only once
  */
  PR_ASSERT(counterLock == NULL);

  counterLock = PR_NewLock();
  PR_INIT_CLIST(&qNameList);
  lm = PR_NewLogModule("counters");
  PR_LOG(lm, PR_LOG_DEBUG, ("PR_Counter: Initialization complete"));

  return;
} /* end _PR_CounterInitialize() */

/*
** PR_CreateCounter() -- Create a counter
**
**  ValidateArguments
**  Lock
**  if (qName not already in database)
**      NewQname
**  if (rName already in database )
**      Assert
**  else NewRname
**  NewCounter
**  link 'em up
**  Unlock
**
*/
PR_IMPLEMENT(PRCounterHandle)
PR_CreateCounter(const char* qName, const char* rName,
                 const char* description) {
  QName* qnp;
  RName* rnp;
  PRBool matchQname = PR_FALSE;

  /* Self initialize, if necessary */
  if (counterLock == NULL) {
    _PR_CounterInitialize();
  }

  /* Validate input arguments */
  PR_ASSERT(strlen(qName) <= PRCOUNTER_NAME_MAX);
  PR_ASSERT(strlen(rName) <= PRCOUNTER_NAME_MAX);
  PR_ASSERT(strlen(description) <= PRCOUNTER_DESC_MAX);

  /* Lock the Facility */
  PR_Lock(counterLock);

  /* Do we already have a matching QName? */
  if (!PR_CLIST_IS_EMPTY(&qNameList)) {
    qnp = (QName*)PR_LIST_HEAD(&qNameList);
    do {
      if (strcmp(qnp->name, qName) == 0) {
        matchQname = PR_TRUE;
        break;
      }
      qnp = (QName*)PR_NEXT_LINK(&qnp->link);
    } while (qnp != (QName*)&qNameList);
  }
  /*
  ** If we did not find a matching QName,
  **    allocate one and initialize it.
  **    link it onto the qNameList.
  **
  */
  if (matchQname != PR_TRUE) {
    qnp = PR_NEWZAP(QName);
    PR_ASSERT(qnp != NULL);
    PR_INIT_CLIST(&qnp->link);
    PR_INIT_CLIST(&qnp->rNameList);
    strcpy(qnp->name, qName);
    PR_APPEND_LINK(&qnp->link, &qNameList);
  }

  /* Do we already have a matching RName? */
  if (!PR_CLIST_IS_EMPTY(&qnp->rNameList)) {
    rnp = (RName*)PR_LIST_HEAD(&qnp->rNameList);
    do {
      /*
      ** No duplicate RNames are allowed within a QName
      **
      */
      PR_ASSERT(strcmp(rnp->name, rName));
      rnp = (RName*)PR_NEXT_LINK(&rnp->link);
    } while (rnp != (RName*)&qnp->rNameList);
  }

  /* Get a new RName structure; initialize its members */
  rnp = PR_NEWZAP(RName);
  PR_ASSERT(rnp != NULL);
  PR_INIT_CLIST(&rnp->link);
  strcpy(rnp->name, rName);
  strcpy(rnp->desc, description);
  rnp->lock = PR_NewLock();
  if (rnp->lock == NULL) {
    PR_ASSERT(0);
  }

  PR_APPEND_LINK(&rnp->link, &qnp->rNameList); /* add RName to QName's rnList */
  rnp->qName = qnp; /* point the RName to the QName */

  /* Unlock the Facility */
  PR_Unlock(counterLock);
  PR_LOG(lm, PR_LOG_DEBUG,
         ("PR_Counter: Create: QName: %s %p, RName: %s %p\n\t", qName, qnp,
          rName, rnp));

  return ((PRCounterHandle)rnp);
} /*  end PR_CreateCounter() */

/*
**
*/
PR_IMPLEMENT(void)
PR_DestroyCounter(PRCounterHandle handle) {
  RName* rnp = (RName*)handle;
  QName* qnp = rnp->qName;

  PR_LOG(lm, PR_LOG_DEBUG,
         ("PR_Counter: Deleting: QName: %s, RName: %s", qnp->name, rnp->name));

  /* Lock the Facility */
  PR_Lock(counterLock);

  /*
  ** Remove RName from the list of RNames in QName
  ** and free RName
  */
  PR_LOG(lm, PR_LOG_DEBUG,
         ("PR_Counter: Deleting RName: %s, %p", rnp->name, rnp));
  PR_REMOVE_LINK(&rnp->link);
  PR_Free(rnp->lock);
  PR_DELETE(rnp);

  /*
  ** If this is the last RName within QName
  **   remove QName from the qNameList and free it
  */
  if (PR_CLIST_IS_EMPTY(&qnp->rNameList)) {
    PR_LOG(lm, PR_LOG_DEBUG,
           ("PR_Counter: Deleting unused QName: %s, %p", qnp->name, qnp));
    PR_REMOVE_LINK(&qnp->link);
    PR_DELETE(qnp);
  }

  /* Unlock the Facility */
  PR_Unlock(counterLock);
  return;
} /*  end PR_DestroyCounter() */

/*
**
*/
PR_IMPLEMENT(PRCounterHandle)
PR_GetCounterHandleFromName(const char* qName, const char* rName) {
  const char *qn, *rn, *desc;
  PRCounterHandle qh, rh = NULL;
  RName* rnp = NULL;

  PR_LOG(lm, PR_LOG_DEBUG,
         ("PR_Counter: GetCounterHandleFromName:\n\t"
          "QName: %s, RName: %s",
          qName, rName));

  qh = PR_FindNextCounterQname(NULL);
  while (qh != NULL) {
    rh = PR_FindNextCounterRname(NULL, qh);
    while (rh != NULL) {
      PR_GetCounterNameFromHandle(rh, &qn, &rn, &desc);
      if ((strcmp(qName, qn) == 0) && (strcmp(rName, rn) == 0)) {
        rnp = (RName*)rh;
        goto foundIt;
      }
      rh = PR_FindNextCounterRname(rh, qh);
    }
    qh = PR_FindNextCounterQname(NULL);
  }

foundIt:
  PR_LOG(lm, PR_LOG_DEBUG, ("PR_Counter: GetConterHandleFromName: %p", rnp));
  return (rh);
} /*  end PR_GetCounterHandleFromName() */

/*
**
*/
PR_IMPLEMENT(void)
PR_GetCounterNameFromHandle(PRCounterHandle handle, const char** qName,
                            const char** rName, const char** description) {
  RName* rnp = (RName*)handle;
  QName* qnp = rnp->qName;

  *qName = qnp->name;
  *rName = rnp->name;
  *description = rnp->desc;

  PR_LOG(lm, PR_LOG_DEBUG,
         ("PR_Counter: GetConterNameFromHandle: "
          "QNp: %p, RNp: %p,\n\tQName: %s, RName: %s, Desc: %s",
          qnp, rnp, qnp->name, rnp->name, rnp->desc));

  return;
} /*  end PR_GetCounterNameFromHandle() */

/*
**
*/
PR_IMPLEMENT(void)
PR_IncrementCounter(PRCounterHandle handle) {
  PR_Lock(((RName*)handle)->lock);
  ((RName*)handle)->counter++;
  PR_Unlock(((RName*)handle)->lock);

  PR_LOG(lm, PR_LOG_DEBUG,
         ("PR_Counter: Increment: %p, %ld", handle, ((RName*)handle)->counter));

  return;
} /*  end PR_IncrementCounter() */

/*
**
*/
PR_IMPLEMENT(void)
PR_DecrementCounter(PRCounterHandle handle) {
  PR_Lock(((RName*)handle)->lock);
  ((RName*)handle)->counter--;
  PR_Unlock(((RName*)handle)->lock);

  PR_LOG(lm, PR_LOG_DEBUG,
         ("PR_Counter: Decrement: %p, %ld", handle, ((RName*)handle)->counter));

  return;
} /*  end PR_DecrementCounter()  */

/*
**
*/
PR_IMPLEMENT(void)
PR_AddToCounter(PRCounterHandle handle, PRUint32 value) {
  PR_Lock(((RName*)handle)->lock);
  ((RName*)handle)->counter += value;
  PR_Unlock(((RName*)handle)->lock);

  PR_LOG(
      lm, PR_LOG_DEBUG,
      ("PR_Counter: AddToCounter: %p, %ld", handle, ((RName*)handle)->counter));

  return;
} /*  end PR_AddToCounter() */

/*
**
*/
PR_IMPLEMENT(void)
PR_SubtractFromCounter(PRCounterHandle handle, PRUint32 value) {
  PR_Lock(((RName*)handle)->lock);
  ((RName*)handle)->counter -= value;
  PR_Unlock(((RName*)handle)->lock);

  PR_LOG(lm, PR_LOG_DEBUG,
         ("PR_Counter: SubtractFromCounter: %p, %ld", handle,
          ((RName*)handle)->counter));

  return;
} /*  end  PR_SubtractFromCounter() */

/*
**
*/
PR_IMPLEMENT(PRUint32)
PR_GetCounter(PRCounterHandle handle) {
  PR_LOG(
      lm, PR_LOG_DEBUG,
      ("PR_Counter: GetCounter: %p, %ld", handle, ((RName*)handle)->counter));

  return (((RName*)handle)->counter);
} /*  end  PR_GetCounter() */

/*
**
*/
PR_IMPLEMENT(void)
PR_SetCounter(PRCounterHandle handle, PRUint32 value) {
  ((RName*)handle)->counter = value;

  PR_LOG(
      lm, PR_LOG_DEBUG,
      ("PR_Counter: SetCounter: %p, %ld", handle, ((RName*)handle)->counter));

  return;
} /*  end  PR_SetCounter() */

/*
**
*/
PR_IMPLEMENT(PRCounterHandle)
PR_FindNextCounterQname(PRCounterHandle handle) {
  QName* qnp = (QName*)handle;

  if (PR_CLIST_IS_EMPTY(&qNameList)) {
    qnp = NULL;
  } else if (qnp == NULL) {
    qnp = (QName*)PR_LIST_HEAD(&qNameList);
  } else if (PR_NEXT_LINK(&qnp->link) == &qNameList) {
    qnp = NULL;
  } else {
    qnp = (QName*)PR_NEXT_LINK(&qnp->link);
  }

  PR_LOG(lm, PR_LOG_DEBUG,
         ("PR_Counter: FindNextQname: Handle: %p, Returns: %p", handle, qnp));

  return ((PRCounterHandle)qnp);
} /*  end  PR_FindNextCounterQname() */

/*
**
*/
PR_IMPLEMENT(PRCounterHandle)
PR_FindNextCounterRname(PRCounterHandle rhandle, PRCounterHandle qhandle) {
  RName* rnp = (RName*)rhandle;
  QName* qnp = (QName*)qhandle;

  if (PR_CLIST_IS_EMPTY(&qnp->rNameList)) {
    rnp = NULL;
  } else if (rnp == NULL) {
    rnp = (RName*)PR_LIST_HEAD(&qnp->rNameList);
  } else if (PR_NEXT_LINK(&rnp->link) == &qnp->rNameList) {
    rnp = NULL;
  } else {
    rnp = (RName*)PR_NEXT_LINK(&rnp->link);
  }

  PR_LOG(lm, PR_LOG_DEBUG,
         ("PR_Counter: FindNextRname: Rhandle: %p, QHandle: %p, Returns: %p",
          rhandle, qhandle, rnp));

  return ((PRCounterHandle)rnp);
} /*  end PR_FindNextCounterRname() */