source: rtems/cpukit/score/src/smplock.c @ 35453000

/*
 *  COPYRIGHT (c) 1989-2011.
 *  On-Line Applications Research Corporation (OAR).
 *
 *  The license and distribution terms for this file may be
 *  found in the file LICENSE in this distribution or at
 *  http://www.rtems.com/license/LICENSE.
 *
 *  $Id$
 */

#if HAVE_CONFIG_H
#include "config.h"
#endif

#include <rtems/system.h>
#include <rtems/score/smplock.h>
#include <rtems/score/smp.h>
#include <rtems/score/isr.h>

/*
 * Some debug stuff that is being left in, but disabled.  This will keep 
 * a log of lock/unlock sequences that can be printed out when the 
 * lockcount appears to have gotten off track.
 */
/* #define SMPLOCK_DEBUG */
#if defined (SMPLOCK_DEBUG)
  #include <rtems/score/thread.h>
  #include <rtems/bspIo.h>
  #include <rtems/score/percpu.h>
  #if (0)
    #define  ENABLE_ONESHOT_DEBUG_LOGGING
  #else
    #define ENABLE_LOOPED_DEBUG_LOGGING
  #endif
  #define ENABLE_DEBUG_LOGGING 
#endif

/*
 * Prototypes and structures used in the debug lock/unlock error log.
 */
#if defined(ENABLE_DEBUG_LOGGING)
  typedef struct {
    char      action;
    char      lock;
    char      cpu;
    char      count;
    uint32_t  nest_level;
    void      *ret1;
    void      *ret2;
    void      *ret3;
    void      *ret4;
  } debug_spinlog_t;

  extern void start(void);
  extern void _fini(void);

  #define DEBUG_SPINLOG_MAX 1024
  debug_spinlog_t DEBUG_SPINLOG[DEBUG_SPINLOG_MAX];
  int DEBUG_SPINLOG_INDEX = 0;

  static void debug_logit(
    char                             act,
    SMP_lock_spinlock_nested_Control *lock
  );
  static void debug_dump_log(void);
#else
  #define debug_logit( _act, _lock )
  #define debug_dump_log()
#endif

/*
 * SMP spinlock simple methods
 */
void _SMP_lock_spinlock_simple_Initialize(
  SMP_lock_spinlock_simple_Control *lock
)
{
  *lock = 0;
}

ISR_Level _SMP_lock_spinlock_simple_Obtain(
  SMP_lock_spinlock_simple_Control *lock
)
{
   ISR_Level  level = 0;
   uint32_t   value = 1;
   uint32_t   previous;

   /* Note: Disable provides an implicit memory barrier. */
  _ISR_Disable_on_this_core( level );
   do {
     RTEMS_COMPILER_MEMORY_BARRIER();
     SMP_CPU_SWAP( lock, value, previous );
     RTEMS_COMPILER_MEMORY_BARRIER();
   } while (previous == 1);

  return level;
}

void _SMP_lock_spinlock_simple_Release(
  SMP_lock_spinlock_simple_Control *lock,
  ISR_Level                        level
)
{
   *lock = 0;
   _ISR_Enable_on_this_core( level );
}

/*
 * SMP spinlock nested methods.
 */
void _SMP_lock_spinlock_nested_Initialize(
  SMP_lock_spinlock_nested_Control *lock
)
{
  lock->lock = 0;
  lock->count = 0;
  lock->cpu_id = -1;
}

void _SMP_lock_spinlock_nested_Release(
  SMP_lock_spinlock_nested_Control *lock,
  ISR_Level                        level
)
{
  #if defined (RTEMS_DEBUG) || defined(SMPLOCK_DEBUG)
    if ( lock->count == 0 ) {
      printk(
        "\ncpu %d lock %d Releasing spinlock when count is already "
        "zero (%p from %p,%p)?!?!\n",
        bsp_smp_processor_id(),  
        lock->cpu_id,
        lock,
        __builtin_return_address(0),
        __builtin_return_address(1)
      );
      debug_dump_log();
      return;
    }
  #endif

  /* assume we actually have it */
  if (lock->count == 1) {
    lock->cpu_id = -1;
    debug_logit( 'U', lock );
    lock->count  = 0;
    RTEMS_COMPILER_MEMORY_BARRIER();
    lock->lock = 0;
  } else {
    debug_logit( 'u', lock );
    lock->count--;
  }

  _ISR_Enable_on_this_core( level ); 
}

ISR_Level _SMP_lock_spinlock_nested_Obtain(
  SMP_lock_spinlock_nested_Control *lock
)
{
  ISR_Level  level = 0;
  uint32_t   value = 1;
  uint32_t   previous;
  int        cpu_id;

  /* Note: Disable provides an implicit memory barrier. */
  _ISR_Disable_on_this_core( level ); 

  cpu_id = bsp_smp_processor_id();

  /*
   *  Attempt to obtain the lock.  If we do not get it immediately, then
   *  do a single "monitor" iteration.  This should allow the loop to back
   *  off the bus a bit and allow the other core to finish sooner.
   */
  while (1) {
    RTEMS_COMPILER_MEMORY_BARRIER();
    SMP_CPU_SWAP( &lock->lock, value, previous );
    RTEMS_COMPILER_MEMORY_BARRIER();
    if ( previous == 0 ) {
      /* was not locked */
      break;
    }

    /* Deal with nested calls from one cpu */
    if (cpu_id == lock->cpu_id) {
      lock->count++;
      debug_logit( 'l', lock );
      return level;
    }
  }

  lock->cpu_id = cpu_id;
  lock->count = 1;
  debug_logit( 'L', lock );

  return level;
}

/*
 * Debug log for debugging nested lock/unlock problems.
 */
#if defined(ENABLE_DEBUG_LOGGING)
  static void debug_logit(
    char                             act,
    SMP_lock_spinlock_nested_Control *lock
  )
  { 
    debug_debug_spinlog_t *sp;
    if ( DEBUG_SPINLOG_INDEX == DEBUG_SPINLOG_MAX )
      #if defined (ENABLE_LOOPED_DEBUG_LOGGING)
        DEBUG_SPINLOG_INDEX = 0;
      #else
        return;
      #endif

    sp = &DEBUG_SPINLOG[ DEBUG_SPINLOG_INDEX++ ];
    sp->action = act;

    #if 0
      if ( lock == &_ISR_SMP_Lock )
        sp->lock = 'I';
      else 
    #endif
    if ( lock == &_Thread_Dispatch_disable_level_lock )
      sp->lock   = 'D';
    sp->cpu    = bsp_smp_processor_id() + '0';
    sp->count  = lock->count;
    #if 0
      if ( sp->lock == 'I' ) {
        if ( _Thread_Dispatch_smp_spin_lock.id == 0 )
          printk( "not nested %p from %p %p %p %p\n", sp,
          __builtin_return_address(0), __builtin_return_address(1),
          __builtin_return_address(2), __builtin_return_address(3) 
        );
      }
    #endif
    sp->nest_level =  _ISR_Nest_level; 
    sp->ret1 = 0;
    sp->ret2 = 0;
    sp->ret3 = 0;
    sp->ret4 = 0;
    sp->ret1 = __builtin_return_address(0);
    if ( sp->ret1 >= start && sp->ret1 <= _fini ) {
      sp->ret2   = __builtin_return_address(1);
      if ( sp->ret2 >= start && sp->ret2 <= _fini ) {
        sp->ret3   = __builtin_return_address(2);
        if ( sp->ret3 >= start && sp->ret3 <= _fini ) {
          sp->ret4   = __builtin_return_address(3);
        }
      }
    }
  }
  
  static void debug_dump_log(void)
  { 
    debug_debug_spinlog_t *sp;
    int       index;
    bool      done =false;
    
    #if defined (ENABLE_ONESHOT_DEBUG_LOGGING)
      index = 0;
    #else
      if (DEBUG_SPINLOG_INDEX >= DEBUG_SPINLOG_MAX)
        index = 0;
      else
        index = DEBUG_SPINLOG_INDEX;
    #endif


    do {
      sp = &DEBUG_SPINLOG[ index ];
      printk("%d) act %c lock %c cpu %c count=%d nest %d (%p, %p, %p, %p)\n",
        index, sp->action, sp->lock, sp->cpu, sp->count, sp->nest_level, 
        sp->ret1, sp->ret2, sp->ret3, sp->ret4
      );

      index++;
      if (index == DEBUG_SPINLOG_INDEX)
        break;
      if (index >= DEBUG_SPINLOG_MAX)
        index = 0;
    } while (1);
  }
#endif