Linux启动过程中init/main.c中的start_kernel()函数中的lock_kernel()函数
2011-09-28 18:06
495 查看
#ifndef __LINUX_SMPLOCK_H #define __LINUX_SMPLOCK_H #ifdef CONFIG_LOCK_KERNEL
//判断内核是否支持内核锁
//而s3c2410中arch/arm/configs/s3c2410的Code maturity level options下没有定义,所以lock_kernel()什么也不做
#include <linux/sched.h> #include <linux/spinlock.h> #define kernel_locked() (current->lock_depth >= 0) extern int __lockfunc __reacquire_kernel_lock(void); extern void __lockfunc __release_kernel_lock(void); /* * Release/re-acquire global kernel lock for the scheduler */ #define release_kernel_lock(tsk) do { \ if (unlikely((tsk)->lock_depth >= 0)) \ __release_kernel_lock(); \ } while (0) /* * Non-SMP kernels will never block on the kernel lock, * so we are better off returning a constant zero from * reacquire_kernel_lock() so that the compiler can see * it at compile-time. */ #if defined(CONFIG_SMP) && !defined(CONFIG_PREEMPT_BKL) # define return_value_on_smp return #else # define return_value_on_smp #endif static inline int reacquire_kernel_lock(struct task_struct *task) { if (unlikely(task->lock_depth >= 0)) return_value_on_smp __reacquire_kernel_lock(); return 0; } extern void __lockfunc lock_kernel(void) __acquires(kernel_lock); extern void __lockfunc unlock_kernel(void) __releases(kernel_lock); #else #define lock_kernel() do { } while(0) #define unlock_kernel() do { } while(0) #define release_kernel_lock(task) do { } while(0) #define reacquire_kernel_lock(task) 0 #define kernel_locked() 1 #endif /* CONFIG_LOCK_KERNEL */ #endif /* __LINUX_SMPLOCK_H */
//如果定义了CONFIG_LOCK_KERNEL,则转到下面代码
//判断是使用big kernel semaphore还是big kernel lock
//而s3c2410中arch/arm/configs/s3c2410中没有定义
#ifdef CONFIG_PREEMPT_BKL //判断是使用big kernel semaphore还是big kernel lock //而s3c2410中arch/arm/configs/s3c2410中没有定义 /* * The 'big kernel semaphore' * * This mutex is taken and released recursively by lock_kernel() * and unlock_kernel(). It is transparently dropped and reacquired * over schedule(). It is used to protect legacy code that hasn't * been migrated to a proper locking design yet. * * Note: code locked by this semaphore will only be serialized against * other code using the same locking facility. The code guarantees that * the task remains on the same CPU. * * Don't use in new code. */ static DECLARE_MUTEX(kernel_sem); /* * Re-acquire the kernel semaphore. * * This function is called with preemption off. * * We are executing in schedule() so the code must be extremely careful * about recursion, both due to the down() and due to the enabling of * preemption. schedule() will re-check the preemption flag after * reacquiring the semaphore. */ int __lockfunc __reacquire_kernel_lock(void) { struct task_struct *task = current; int saved_lock_depth = task->lock_depth; BUG_ON(saved_lock_depth < 0); task->lock_depth = -1; preempt_enable_no_resched(); down(&kernel_sem); preempt_disable(); task->lock_depth = saved_lock_depth; return 0; } void __lockfunc __release_kernel_lock(void) { up(&kernel_sem); } /* * Getting the big kernel semaphore. */ void __lockfunc lock_kernel(void) { struct task_struct *task = current; int depth = task->lock_depth + 1; if (likely(!depth)) /* * No recursion worries - we set up lock_depth _after_ */ down(&kernel_sem); task->lock_depth = depth; } void __lockfunc unlock_kernel(void) { struct task_struct *task = current; BUG_ON(task->lock_depth < 0); if (likely(--task->lock_depth < 0)) up(&kernel_sem); } #else /* * The 'big kernel lock' * * This spinlock is taken and released recursively by lock_kernel() * and unlock_kernel(). It is transparently dropped and reacquired * over schedule(). It is used to protect legacy code that hasn't * been migrated to a proper locking design yet. * * Don't use in new code. */ static __cacheline_aligned_in_smp DEFINE_SPINLOCK(kernel_flag); /* * Acquire/release the underlying lock from the scheduler. * * This is called with preemption disabled, and should * return an error value if it cannot get the lock and * TIF_NEED_RESCHED gets set. * * If it successfully gets the lock, it should increment * the preemption count like any spinlock does. * * (This works on UP too - _raw_spin_trylock will never * return false in that case) */ int __lockfunc __reacquire_kernel_lock(void) { while (!_raw_spin_trylock(&kernel_flag)) { if (test_thread_flag(TIF_NEED_RESCHED)) return -EAGAIN; cpu_relax(); } preempt_disable(); return 0; } void __lockfunc __release_kernel_lock(void) { _raw_spin_unlock(&kernel_flag); preempt_enable_no_resched(); } /* * These are the BKL spinlocks - we try to be polite about preemption. * If SMP is not on (ie UP preemption), this all goes away because the * _raw_spin_trylock() will always succeed. */ #ifdef CONFIG_PREEMPT
//使用big kernel lock的情况下,判断内核是否支持抢占式调度,支持则执行下面的代码
//而我们使用的s3c2410是单处理器的,不存在多个CPU竞争资源的情况,所以不需要用大内核锁/信号量来解决资源竞争的问题
//CONFIG_PREEMPT在arch/arm/configs/s3c2410_deconfig中Kernel Features下,在s3c2410中定义为# CONFIG_PREEMPT is not set
static inline void __lock_kernel(void) { preempt_disable(); if (unlikely(!_raw_spin_trylock(&kernel_flag))) { /* * If preemption was disabled even before this * was called, there's nothing we can be polite * about - just spin. */ if (preempt_count() > 1) { _raw_spin_lock(&kernel_flag); return; } /* * Otherwise, let's wait for the kernel lock * with preemption enabled.. */ do { preempt_enable(); while (spin_is_locked(&kernel_flag)) cpu_relax(); preempt_disable(); } while (!_raw_spin_trylock(&kernel_flag)); } } #else /* * Non-preemption case - just get the spinlock */ static inline void __lock_kernel(void) { _raw_spin_lock(&kernel_flag); } #endif static inline void __unlock_kernel(void) { /* * the BKL is not covered by lockdep, so we open-code the * unlocking sequence (and thus avoid the dep-chain ops): */ _raw_spin_unlock(&kernel_flag); preempt_enable(); } /* * Getting the big kernel lock. * * This cannot happen asynchronously, so we only need to * worry about other CPU's. */ void __lockfunc lock_kernel(void) { int depth = current->lock_depth+1; //lock_depth的初始值为-1,所以depth=0 if (likely(!depth)) //通过 __lock_kernel(); //执行 current->lock_depth = depth; } void __lockfunc unlock_kernel(void) { BUG_ON(current->lock_depth < 0); if (likely(--current->lock_depth < 0)) __unlock_kernel(); } #endif EXPORT_SYMBOL(lock_kernel); EXPORT_SYMBOL(unlock_kernel);
相关文章推荐
- kernel 启动过程之三, start_kernel()函数 概叙!init/main.c
- kernel 启动过程之三, start_kernel()函数 概叙!init/main.c
- kernel 启动过程之三, start_kernel()函数 概叙!init/main.c
- kernel 启动过程之三, start_kernel()函数 概叙!init/main.c
- kernel 启动过程之三, start_kernel()函数 概叙!init/main.c
- kernel 启动过程之三, start_kernel()函数 概叙!init/main.c .
- kernel 启动过程之三, start_kernel()函数 概叙!init/main.c
- kernel 启动过程之四,start_kernel中的rest_init函数到init进程
- 分析Linux内核启动过程:从start_kernel到init
- 分析Linux内核启动过程:从start_kernel到init
- 跟踪分析Linux内核的启动过程(start_kernel到init进程启动)
- kernel 启动过程之四,start_kernel中的rest_init函数到init进程
- kernel 启动过程之四,start_kernel中的rest_init函数到init进程
- linux启动流程(从start_kernel中的rest_init函数到init进程(1))
- 嵌入式ARM Linux kernel启动过程之浅尝辄止分析start_kernel函数
- 利用gdb分析从start_kernel到init启动的过程
- linux编程之main()函数启动过程
- linux启动start_kernel之console_init
- Linux 启动代码 Start_kernel()函数分析
- linux启动分析---C程序入口函数start_kernel