linux调度锁,Linux内核锁 —— 进程调度

一、进程调度

调度的发生有两种方式

1、主动式

在内核中直接调用schedule()。当进程需要等待资源等而暂时停止运行时，

会把状态置于挂起(睡眠)，并主动请求调度，让出CPU。主动放弃cpu例:

current->state = TASK_INTERRUPTIBLE;

schedule();

2、被动式(抢占)

被动式又分两种情况

用户抢占(Linux2.4、Linux2.6)

内核抢占(Linux2.6)

用户抢占发生在：

从系统调用返回用户空间。

从中断处理程序返回用户空间。

内核即将返回用户空间的时候，如果need_resched标志被设置，会导致schedule()被调用，此时就会发生用户抢占.

* ENTRY(ret_from_exception) //异常返回

get_thread_info tsk

mov why, #0

b ret_to_user

* __irq_usr: //在用户态收到中断

usr_entry

kuser_cmpxchg_check

…… …… ……

b ret_to_user

ENTRY(ret_to_user)

ret_slow_syscall:

disable_irq @ disable interrupts

ldrr1, [tsk, #TI_FLAGS]

tstr1, #_TIF_WORK_MASK

bne work_pending

work_pending:

tstr1, #_TIF_NEED_RESCHED

bne work_resched

work_resched:

bl schedule

内核抢占:

在不支持内核抢占的系统中，进程/线程一旦运行于内核空间，就可以一直执行，直到它主动放弃或时间片耗尽为止。这样一些非常紧急的进程或线程将长时间得不到运行。

在支持内核抢占的系统中，更高优先级的进程/线程可以抢占正在内核空间运行的低优先级进程/线程。

在支持内核抢占的系统中，某些特例下是不允许内核抢占的：

内核正进行中断处理(包括软中断/下半部)。进程调度函数schedule()会对此作出判断，如果是在中断中调用，会打印出错信息。

进程正持有锁(如spinlock自旋锁、writelock/readlock读写锁等)，当持有这些锁时，不应该被抢占，否则由于抢占将导致其他CPU长期不能获得锁而死等。

内核正在执行调度程序Scheduler。抢占的原因就是为了进行新的调度，没有理由将调度程序抢占掉再运行调度程序。

为保证Linux内核在以上情况下不会被抢占，抢占式内核使用了一个变量preempt_count，称为内核抢占计数。

这一变量被设置在进程的thread_info结构中。每当内核要进入以上几种状态时，变量preempt_count就加1，

指示内核不允许抢占。每当内核从以上几种状态退出时，变量preempt_count就减1，同时进行可抢占的判断与调度。

内核抢占可能发生在：

中断处理程序完成，返回内核空间之前。

当内核代码再一次具有可抢占性的时候，如解锁及使能软中断等。

内核抢占(中断):

__irq_svc: /*内核态接收到中断*/

svc_entry

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

/*进入中断，抢占计数加1*/

#ifdef CONFIG_PREEMPT

get_thread_info tsk

ldr r8, [tsk, #TI_PREEMPT] @ get preempt count

add r7, r8, #1 @ increment it

str r7, [tsk, #TI_PREEMPT]

#endif

irq_handler /*中断处理*/

#ifdef CONFIG_PREEMPT

str r8, [tsk, #TI_PREEMPT] @ restore preempt count

ldr r0, [tsk, #TI_FLAGS] @ get flags

teq r8, #0 @ if preempt count != 0

movne r0, #0 @ force flags to 0

tst r0, #_TIF_NEED_RESCHED

blne svc_preempt

#endif

svc_preempt:

mov r8, lr

1: bl preempt_schedule_irq /*调度*/

ldr r0, [tsk, #TI_FLAGS]

tst r0, #_TIF_NEED_RESCHED

moveqpc, r8

内核抢占(解锁):

void __lockfunc _spin_unlock(spinlock_t

*lock)

{

spin_release(&lock->dep_map, 1,

_RET_IP_);

_raw_spin_unlock(lock);

preempt_enable();

}

define preempt_enable() \

do { \

preempt_enable_no_resched(); \

barrier(); \

preempt_check_resched(); \

} while (0)

#define preempt_enable_no_resched() \

do { \

barrier(); \

dec_preempt_count();\

/*抢占计数减一*/

} while (0)

#define preempt_check_resched() \

do { \

if (unlikely(test_thread_flag(TIF_NEED_RESCHED))) \

preempt_schedule();\ /*调度*/

} while (0)

** 总结: **

schedule()函数被调用

进程自己主动调用schedule()

从(软)中断处理程序(系统调用也是一种中断)返回内核空间/用户空间。

当内核代码再一次具有可抢占性的时候，如解锁及使能软中断等。

文档信息

--------------

* 作者:

* 版权声明：自由转载-非商用

* 转载: []