Skip to contentSkip to conversation

Recursive spinlocks for Network Recursion Bugs in 2.6.18

DISCUSSION Jeffrey V. Merkey 2 participants 2 messages Dec 9, 2006 – Dec 12, 2006

lore
Share & tools
lore
#0 lore raw

This code segment in /net/core/dev.c is a prime example of the need for recursive spin locks.

      if (dev->flags & IFF_UP) {
               int cpu = smp_processor_id(); /* ok because BHs are off */

               if (dev->xmit_lock_owner != cpu) {

                       HARD_TX_LOCK(dev, cpu);

                       if (!netif_queue_stopped(dev)) {
                               rc = 0;
                               if (!dev_hard_start_xmit(skb, dev)) {
                                       HARD_TX_UNLOCK(dev);
                                       goto out;
                               }
                       }
                       HARD_TX_UNLOCK(dev);
                       if (net_ratelimit())
                               printk(KERN_CRIT "Virtual device %s asks 
to "
                                      "queue packet!\n", dev->name);
               } else {
                       /* Recursion is detected! It is possible,
                        * unfortunately */
                       if (net_ratelimit())
                               printk(KERN_CRIT "Dead loop on virtual 
device "
                                      "%s, fix it urgently!\n", dev->name);
               }
       }

Recursive spinlocks perform the logic

rspin_lock(spin_lock)
{
if (spin_lock->lock->cpu_owner = cpu I am on) && (spin_lock->lock)

  {
      spin_lock->use_count++;
  }
   else
   {
         spin_lock(lock)
         lock->cpu_owner = cpu I am on;
         lock->use_count++;

}
}

rspin_unlock(spin_lock)
{
if (spin_lock->lock->cpu_owner = cpu I am on) && (spin_lock->use_count)

  {
      spin_lock->use_count--;
  }
   else
   {   
          lock->use_count++;     
          lock->cpu_owner = cpu I am on;
          spin_unlock(lock)

}
}

One implementation of this is:

LONG rspin_lock(rlock_t *rlock)
{
register LONG proc = get_processor_id();
register LONG retCode;

  if (rlock->lockValue && rlock->processor == (proc + 1))
  {
     rlock->count++;
     retCode = 1;
  }
  else
  {
     dspin_lock(&rlock->lockValue);
     rlock->processor = (proc + 1);
     retCode = 0;
  }

return retCode;

}
LONG rspin_unlock(rlock_t *rlock)
{

register LONG retCode;

  if (rlock->count)
  {
     rlock->count--;
     retCode = 1;
  }
  else
  {
     rlock->processor = 0;
     dspin_unlock(&rlock->lockValue);
     retCode = 0;
  }

return retCode;
}

Just a suggestion. Would be a useful primitive for a lot of context implementations where users turn on interrupts inside of nested spin lock code.

Jeff

#1 lore raw
Quoted 4 lines · Jeffrey V. Merkey

This code segment in /net/core/dev.c is a prime example of the need for recursive spin locks.

...

Quoted 1 line

Recursive spinlocks perform the logic

...

Quoted 1 line

LONG rspin_lock(rlock_t *rlock)

...

Quoted 1 line

LONG rspin_unlock(rlock_t *rlock)

...

Could you give some hint how this code from dev.c
should be changed to gain by this?

Jarek P.