SpinLock Class Reference

自旋锁 More...

#include <spinlock.hpp>

Collaboration diagram for SpinLock:

Public Member Functions
__always_inline auto	Lock () -> Expected< void >
	获得锁
__always_inline auto	UnLock () -> Expected< void >
	释放锁
构造/析构函数
	SpinLock (const char *_name)
	构造函数
	SpinLock ()=default
	SpinLock (const SpinLock &)=delete
	SpinLock (SpinLock &&)=default
auto	operator= (const SpinLock &) -> SpinLock &=delete
auto	operator= (SpinLock &&) -> SpinLock &=default
	~SpinLock ()=default

Public Attributes
const char *	name {"unnamed"}
	自旋锁名称

Protected Member Functions
__always_inline auto	IsLockedByCurrentCore () -> bool
	检查当前 core 是否获得此锁

Protected Attributes
std::atomic_flag	locked_ {ATOMIC_FLAG_INIT}
	是否 Lock
std::atomic< size_t >	core_id_ {std::numeric_limits<size_t>::max()}
	获得此锁的 core_id
bool	saved_intr_enable_ {false}
	保存的中断状态

Detailed Description

自旋锁

Copyright

Copyright The SimpleKernel Contributors

Note

使用限制：

1. 不可重入：不支持同一核心递归获取锁，会导致返回失败
2. 关中断：获取锁时会自动关闭中断，释放锁时恢复之前的状态
3. 必须配对：必须在获取锁的同一个核心释放锁
4. 不可休眠：持有自旋锁期间不可执行休眠或调度操作
5. 副作用：修改当前 CPU 的中断状态

Definition at line 27 of file spinlock.hpp.

Constructor & Destructor Documentation

SpinLock() [1/4]

SpinLock::SpinLock ( const char *  _name )

inlineexplicit

构造函数

Parameters

_name

锁名

Note

需要堆初始化后可用

Definition at line 92 of file spinlock.hpp.

: name(_name) {}

SpinLock() [2/4]

SpinLock::SpinLock ( )

default

SpinLock() [3/4]

SpinLock::SpinLock ( const SpinLock &  )

delete

SpinLock() [4/4]

SpinLock::SpinLock ( SpinLock &&  )

default

~SpinLock()

SpinLock::~SpinLock ( )

default

Member Function Documentation

IsLockedByCurrentCore()

__always_inline auto SpinLock::IsLockedByCurrentCore ( ) -> bool

inlineprotected

检查当前 core 是否获得此锁

Returns

true 是

false 否

Definition at line 115 of file spinlock.hpp.

                                                       {
    return locked_.test(std::memory_order_acquire) &&
           (core_id_.load(std::memory_order_acquire) ==
            cpu_io::GetCurrentCoreId());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Lock()

__always_inline auto SpinLock::Lock ( ) -> Expected<void>

inline

获得锁

Returns

Expected<void> 成功返回空值，失败返回错误

Definition at line 36 of file spinlock.hpp.

                                                              {
    auto intr_enable = cpu_io::GetInterruptStatus();
    cpu_io::DisableInterrupt();
 
    // 先尝试获取锁
    while (locked_.test_and_set(std::memory_order_acquire)) {
      // 在等待时检查是否是当前核心持有锁（递归锁检测）
      if (core_id_.load(std::memory_order_acquire) ==
          cpu_io::GetCurrentCoreId()) {
        // 递归锁定，恢复中断状态并返回失败
        if (intr_enable) {
          cpu_io::EnableInterrupt();
        }
        // klog::Err("spinlock {}: {} recursive lock detected.",
        //           cpu_io::GetCurrentCoreId(), name);
        return std::unexpected(Error{ErrorCode::kSpinLockRecursiveLock});
      }
      cpu_io::Pause();
    }
 
    // 获取锁成功后立即设置 core_id_
    core_id_.store(cpu_io::GetCurrentCoreId(), std::memory_order_release);
    saved_intr_enable_ = intr_enable;
    return {};
  }

Here is the call graph for this function:

operator=() [1/2]

auto SpinLock::operator= ( const SpinLock &  ) -> SpinLock &=delete

delete

operator=() [2/2]

auto SpinLock::operator= ( SpinLock &&  ) -> SpinLock &=default

default

UnLock()

__always_inline auto SpinLock::UnLock ( ) -> Expected<void>

inline

释放锁

Returns

Expected<void> 成功返回空值，失败返回错误

Definition at line 66 of file spinlock.hpp.

                                                                {
    if (!IsLockedByCurrentCore()) {
      // klog::Err("spinlock {}: {} unlock by non-owner detected.",
      //           cpu_io::GetCurrentCoreId(), name);
      return std::unexpected(Error{ErrorCode::kSpinLockNotOwned});
    }
 
    // 先重置 core_id_，再释放锁
    core_id_.store(std::numeric_limits<size_t>::max(),
                   std::memory_order_release);
    locked_.clear(std::memory_order_release);
 
    if (saved_intr_enable_) {
      cpu_io::EnableInterrupt();
    }
    return {};
  }

Here is the call graph for this function:

Member Data Documentation

core_id_

std::atomic<size_t> SpinLock::core_id_ {std::numeric_limits<size_t>::max()}

protected

获得此锁的 core_id

Definition at line 106 of file spinlock.hpp.

{std::numeric_limits<size_t>::max()};

locked_

std::atomic_flag SpinLock::locked_ {ATOMIC_FLAG_INIT}

protected

是否 Lock

Definition at line 104 of file spinlock.hpp.

{ATOMIC_FLAG_INIT};

name

const char* SpinLock::name {"unnamed"}

自旋锁名称

Definition at line 30 of file spinlock.hpp.

{"unnamed"};

saved_intr_enable_

bool SpinLock::saved_intr_enable_ {false}

protected

保存的中断状态

Definition at line 108 of file spinlock.hpp.

{false};

---

The documentation for this class was generated from the following file:

• /workspaces/SimpleKernel/src/include/spinlock.hpp