spin_lock_irq 不明白 望指导

tc1989tc

自旋锁的代码调用流程大致如下，
但是只看见其中local_irq_disable()将本地中断关闭，
但是下面的preempt_disable();
        spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
        LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
        代码看不懂。个人理解既然关闭啦中断。那么为啥还要执行下面的do_raw_spin_lock
        函数啊？

函数调用流程如下：
spin_lock_irq -> raw_spin_lock_irq->__raw_spin_lock_irq

static inline void spin_lock_irq(spinlock_t *lock)
{
        raw_spin_lock_irq(&lock->rlock);
}

#define raw_spin_lock_irq(lock)                _raw_spin_lock_irq(lock)

void __lockfunc _raw_spin_lock_irq(raw_spinlock_t *lock)
{
        __raw_spin_lock_irq(lock);
}

static inline void __raw_spin_lock_irq(raw_spinlock_t *lock)
{
        local_irq_disable();
        preempt_disable();
        spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
        LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
}


请问忙等待那段代码在哪个函数呢 我没有找到。谁知道啊

tc1989tc

有理解的吗

tc1989tc

x86下面是这样的：
static __always_inline void arch_spin_lock(arch_spinlock_t *lock)
{
        register struct __raw_tickets inc = { .tail = TICKET_LOCK_INC };

        inc = xadd(&lock->tickets, inc);
        if (likely(inc.head == inc.tail))
                goto out;

        inc.tail &= ~TICKET_SLOWPATH_FLAG;
        for (; {
                unsigned count = SPIN_THRESHOLD;

                do {
                        if (ACCESS_ONCE(lock->tickets.head) == inc.tail)
                                goto out;
                        cpu_relax();
                } while (--count);
                __ticket_lock_spinning(lock, inc.tail);
        }
out:        barrier();        /* make sure nothing creeps before the lock is taken */
}

tc1989tc

1. static __always_inline void arch_spin_lock(arch_spinlock_t *lock)
   
2. {
   
3.         register struct __raw_tickets inc = { .tail = TICKET_LOCK_INC };
   
4. 
   
5.         inc = xadd(&lock->tickets, inc);
   
6.         if (likely(inc.head == inc.tail))
   
7.                 goto out;
   
8. 
   
9.         inc.tail &= ~TICKET_SLOWPATH_FLAG;
   
10.         for (;;) {
    
11.                 unsigned count = SPIN_THRESHOLD;
    
12. 
    
13.                 do {
    
14.                         if (ACCESS_ONCE(lock->tickets.head) == inc.tail)
    
15.                                 goto out;
    
16.                         cpu_relax();
    
17.                 } while (--count);
    
18.                 __ticket_lock_spinning(lock, inc.tail);
    
19.         }
    
20. out:        barrier();        /* make sure nothing creeps before the lock is taken */
    
21. }
    

复制代码

nswcfd

TICKET_SLOWPATH_FLAG这个标记做什么用的？

firocu

从代码结构上看, 是为了虚拟化加的一个优化.
个人理解可能是虚拟化的是spin lock可能比较频繁.

下面是不完整的commit信息. 完整信息 自己git show一下吧.

commit 96f853eaa889c7a22718d275b0df7bebdbd6780e
Author: Jeremy Fitzhardinge <jeremy@goop.org>
Date:   Fri Aug 9 19:51:58 2013 +0530

    x86, ticketlock: Add slowpath logic
   
    Maintain a flag in the LSB of the ticket lock tail which indicates
    whether anyone is in the lock slowpath and may need kicking when
    the current holder unlocks.  The flags are set when the first locker
    enters the slowpath, and cleared when unlocking to an empty queue (ie,
    no contention).
   
    In the specific implementation of lock_spinning(), make sure to set
    the slowpath flags on the lock just before blocking.  We must do
    this before the last-chance pickup test to prevent a deadlock
    with the unlocker:
   
    Unlocker                    Locker
                                test for lock pickup
                                        -> fail
    unlock
    test slowpath
        -> false
                                set slowpath flags
                                block
   
    Whereas this works in any ordering:
   
    Unlocker                    Locker
                                set slowpath flags
                                test for lock pickup
                                        -> fail
                                block
    unlock
    test slowpath

回复 5# nswcfd


   

nswcfd

好的，多谢提供信息。

不过还是没太看明白

l4rmbr

回复 1# tc1989tc

static inline void __raw_spin_lock_irq(raw_spinlock_t *lock)
{
        local_irq_disable();
        preempt_disable();
        spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
        LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
}

    为什么你觉得一个自旋锁关了中断后就可以了，而不用去拿锁？ 那这个为什么叫自旋锁？

这个api 存在的理由是，保护临界区被从中断上下文访问。 所以， 要关闭本地中断。为什么要关闭“本地”中断？
如果不关。你在进程上下文拿这个锁，在本 CPU 上， 来了中断， 在中断处理函数里，也想拿这个自旋锁，这时
就会自旋等锁释放。问题是，拿锁的进程被你中断打断了，你一直在自旋； 拿锁的进程没法前进，锁是不会释放了，
然后就死锁了。

上面解释了为什么要关本地中断的原因了。然后进程真正该做的，拿自旋锁。先用 do_raw_spin_trylock 尝试，如果拿到，搞定;
否则，进入慢速路径，在do_raw_spin_lock里，要自旋，以等待锁的释放。

tc1989tc

回复 8# l4rmbr


   嗯是的，谢谢  我开始想到单cpu的形式啦  所以锁相关的
  东东就是费脑