linux内和分析之sched.c程序

最新推荐文章于 2024-08-21 01:52:42 发布
最新推荐文章于 2024-08-21 01:52:42 发布
阅读量5.5k 收藏 5
点赞数
文章标签： linux 任务 struct timer math list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tq02h2a/article/details/2956365
版权

该内核程序主要包含进程调度程序的实现。进程调度采用了基于优先级的时间片轮转算法。

#include <linux/sched.h> 
#include <linux/kernel.h> 
#include <linux/sys.h> 
#include <linux/fdreg.h> 
#include <asm/system.h>  
#include <asm/io.h>  
#include <asm/segment.h> 
#include <signal.h>  

这是一个宏，用来取得信号的二进制数值。
输入：信号编号，1-32
输出：信号的二进制数值
#define _S(nr) (1<<((nr)-1))

被阻塞的信号掩码，其中有两个信号不能被阻塞SIGKLL和SIGSTOP。这两个信号的
位为0，其他位为1 
#define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))

显示制定任务的信息:包括进程id，任务号，任务当前状态以及指定任务内核态堆栈空闲的字节数
void
show_task (int nr, struct task_struct *p)
{
  任务的内核态堆栈的大小不能大于4KB，计算除去task结构所剩余的栈空间
  int i, j = 4096 - sizeof (struct task_struct);
  打印任务的进程id，当前状态，任务号
  printk ("%d: pid=%d, state=%d, ", nr, p->pid, p->state);

  开始计算除task结构所占用的栈空间外，还剩余的空闲内核栈空间
  i = 0;
  while (i < j && !((char *) (p + 1))[i])
    i++;
  打印计算结果
  printk ("%d (of %d) chars free in kernel stack/n/r", i, j);
}

打印所有任务的信息
NR_TASKS表示系统允许的最大任务数量
void
show_stat (void)
{
  int i;
  遍历task数组，打印信息
  for (i = 0; i < NR_TASKS; i++) 
    if (task[i])  
      show_task (i, task[i]);
}


#define LATCH (1193180/HZ)

申明外部定义的函数。
extern void mem_use (void); 
extern int timer_interrupt (void); 
extern int system_call (void); 

一个联合体，该联合体既可以用字节形式表示，也可以用任务结构表示。
我们知道一个任务的内核堆栈大小是4KB,即一页大小。
union task_union
{    
  struct task_struct task; 
  char stack[PAGE_SIZE]; 
};

定义初始化任务数组
static union task_union init_task = { INIT_TASK, }; 

定义变量，从开机起经过的滴答数，10ms为一个滴答，将变量申明为volatile是因为
防止编译器优化而导致的变量值不一致的情况。优化后变量值很有可能直接来自寄存器
我们使用此变量申明修饰符，保证每次从内存中取变量的值。
long volatile jiffies = 0; 

从开机后经历的秒数。从1970年1月1日0时开始计算。
long startup_time = 0;  

初始化当前任务指针。
struct task_struct *current = &(init_task.task);

使用过协处理器的任务指针 
struct task_struct *last_task_used_math = NULL;

初始化任务数组 
struct task_struct *task[NR_TASKS] = { &(init_task.task), };

定义任务堆栈，大小为1024个4字节的项组成。 
long user_stack[PAGE_SIZE >> 2]; 

定义内核数据段的一个结构体，该结构体中包括
一个内核堆栈指针和一个段选择符
0x10:内核数据段段选择符
struct
{
  long *a;
  short b;
}
stack_start =
{
&user_stack[PAGE_SIZE >> 2], 0x10};

当任务发生切换的时候，用来保存上一个任务的协处理器上下文环境，恢复当前任务的
协处理器上下文环境。
void
math_state_restore ()
{
  先判断当前换入的任务是不是上次被换出的任务，如果是直接返回
  if (last_task_used_math == current) 
    return;   
  对协处理器发送命令前，应该先执行fwait指令。
  __asm__ ("fwait"); 
  看看被换出的任务使用了协处理器没有，如果有就保存协处理器上下文
  if (last_task_used_math)
    {    
      __asm__ ("fnsave %0"::"m" (last_task_used_math->tss.i387));
    }
  并置上次换出任务指针为当前任务
  last_task_used_math = current; 
  判断当前任务是否使用了协处理器，如果是恢复协处理器的上下文。如果是
  第一次使用，需要进行协处理器初始化工作。
  if (current->used_math)
    {    
      __asm__ ("frstor %0"::"m" (current->tss.i387));
    }
  else
    {    
      __asm__ ("fninit"::);
      current->used_math = 1;
    }
}

核心进程调度程序
void
schedule (void)
{
  int i, next, c;
  struct task_struct **p; 

  从最够一个任务开始遍历
  for (p = &LAST_TASK; p > &FIRST_TASK; --p)
    如果任务数组中所指的任务不为NULL
    if (*p)
      {
       判断定时器是否到期，如果到期需要在信号位图中置SIGALARM位，并且将定时器清0
 if ((*p)->alarm && (*p)->alarm < jiffies)
   {
     (*p)->signal |= (1 << (SIGALRM - 1));
     (*p)->alarm = 0;
   }
       如果信号位图中表示有非阻塞信号被递送，该任务的状态是可中断的，那么将该任务状态置为就绪
 if (((*p)->signal & ~(_BLOCKABLE & (*p)->blocked)) &&
     (*p)->state == TASK_INTERRUPTIBLE)
   (*p)->state = TASK_RUNNING; 
      }

  检查就绪的任务，判断下一个运行的任务。
  while (1)
    {
  从最后一个任务开始遍历任务数组
      c = -1;
      next = 0;
      i = NR_TASKS;
      p = &task[NR_TASKS];
      对就绪任务按照时间片进行排序。
      while (--i)
 {
   if (!*--p)
     continue；
   if ((*p)->state == TASK_RUNNING && (*p)->counter > c)
     c = (*p)->counter, next = i;
 }
      如果最大时间片不为0，那么就切换到该任务去运行
      if (c)
 break;
      如果所有任务的时间片都为0，那么重新计算各个任务的时间片，计算原则是根据优先级进行计算
      然后从新选择时间片最大的任务去运行。
      for (p = &LAST_TASK; p > &FIRST_TASK; --p)
 if (*p)
   (*p)->counter = ((*p)->counter >> 1) + (*p)->priority;
    }

  任务切换
  switch_to (next);  
}

将该任务置为可中断状态，然后执行任务调度程序
int
sys_pause (void)
{
  current->state = TASK_INTERRUPTIBLE;
  schedule ();
  return 0;
}

在指定任务上睡眠，任务0不能睡眠。如果cpu上没有任务运行时就运行任务0，该函数是
不可中断的。
void
sleep_on (struct task_struct **p)
{
  struct task_struct *tmp;

  if (!p)
    return;
  如果当前任务为任务0，死机。
  if (current == &(init_task.task)) 
    panic ("task[0] trying to sleep");
  将该任务挂靠在tmp指针上，等下次被调度的时候在引用该指针
  tmp = *p;   
  *p = current;   
  置当前任务为不可中断状态
  current->state = TASK_UNINTERRUPTIBLE;
  进程调度 
  schedule ();
  该进程下次被调度到的时候，将任务的状态置为0，唤醒。   
  if (tmp)   
    tmp->state = 0;
}

该函数与上面的那个sleep函数的区别在于，如果下次再次调度到
睡眠的进程的时候，判断如果当前进程是睡眠的进程，需要重新进行
调度。
void
interruptible_sleep_on (struct task_struct **p)
{
  struct task_struct *tmp;

  if (!p)
    return;
  if (current == &(init_task.task))
    panic ("task[0] trying to sleep");
  tmp = *p;
  *p = current;
repeat:current->state = TASK_INTERRUPTIBLE;
  schedule ();
  if (*p && *p != current)
    {
      (**p).state = 0;
      goto repeat;
    }
  *p = NULL;
  if (tmp)
    tmp->state = 0;
}

将任务数组中的任务置为就绪唤醒状态，然后置该任务数组项为0.
void
wake_up (struct task_struct **p)
{
  if (p && *p)
    {
      (**p).state = 0;  
      *p = NULL;
    }
}


定义了timer list的最大长度
#define TIME_REQUESTS 64 

定义timer list结构
static struct timer_list
{
  系统开机开始算起的滴答数
  long jiffies; 
  定时器的回调函数  
  void (*fn) ();
  指向下一个timer节点  
  struct timer_list *next;
}
timer_list[TIME_REQUESTS], *next_timer = NULL;

加入定时器
void add_timer (long jiffies, void (*fn) (void))
{
  struct timer_list *p;
  如果回调函数为空，就返回。
  if (!fn)
    return;
  禁止中断
  cli ();
  如果滴答数到期，回调timeout函数
  if (jiffies <= 0)
    (fn) ();
  else
    {
      遍历定时器链表，判断是否有可用的节点
      for (p = timer_list; p < timer_list + TIME_REQUESTS; p++)
 if (!p->fn)
   break;
      如果定时器数组越界，死机
      if (p >= timer_list + TIME_REQUESTS)
 panic ("No more time requests free");
      付值
      p->fn = fn;
      p->jiffies = jiffies;
      p->next = next_timer;
      next_timer = p;
      对定时器链表进行排序，从小到大，并且将后面的滴答数递减他前面节点的滴答数，
      也就是说，还有多少个滴答才会到下一个定时器expire.
      while (p->next && p->next->jiffies < p->jiffies)
 {
   p->jiffies -= p->next->jiffies;
   fn = p->fn;
   p->fn = p->next->fn;
   p->next->fn = fn;
   jiffies = p->jiffies;
   p->jiffies = p->next->jiffies;
   p->next->jiffies = jiffies;
   p = p->next;
 }
    }
  开启可屏蔽中断
  sti ();
}

时钟中断处理函数调用此C函数。
void
do_timer (long cpl)
{
  extern int beepcount;  
  extern void sysbeepstop (void); 

  if (beepcount)
    if (!--beepcount)
      sysbeepstop ();
  如果当前任务的CPL为3，将用户时间递增，否则递增系统时间。
  if (cpl)
    current->utime++;
  else
    current->stime++;

  将滴答数递减，如果滴答数小于等于0了，就需要回调超时回调函数然后将
  超时节点这个资源归还给系统。即next_timer->fn = NULL;循环处理，直到
  遍历完整个链表。
  if (next_timer)
    {    
      next_timer->jiffies--;
      while (next_timer && next_timer->jiffies <= 0)
 {
   void (*fn) (void); 

   fn = next_timer->fn;
   next_timer->fn = NULL;
   next_timer = next_timer->next;
   (fn) ();  
 }
    }
  这部分是对软驱的处理，在这里不讲
  if (current_DOR & 0xf0)
    do_floppy_timer ();
  if ((--current->counter) > 0)
    return;   
  current->counter = 0;
  if (!cpl)
    return;

  中断执行完成，重新调度任务  
  schedule ();
}

设置定时器，返回上次设置的定时器剩余的秒数
将新的秒数转换成滴答数，设置到当前进程中去
int
sys_alarm (long seconds)
{
  int old = current->alarm;

  if (old)
    old = (old - jiffies) / HZ;
  current->alarm = (seconds > 0) ? (jiffies + HZ * seconds) : 0;
  return (old);
}


int
sys_getpid (void)
{
  return current->pid;
}

取进程id
int
sys_getppid (void)
{
  return current->father;
}

取用户id
int
sys_getuid (void)
{
  return current->uid;
}


取有效用户id
int
sys_geteuid (void)
{
  return current->euid;
}

取组id
int
sys_getgid (void)
{
  return current->gid;
}

取有效组id
int
sys_getegid (void)
{
  return current->egid;
}

设置进程nice值，即降低优先级
int
sys_nice (long increment)
{
  if (current->priority - increment > 0)
    current->priority -= increment;
  return 0;
}

在main.c中调用，对schedle进行初始化。
void
sched_init (void)
{
  int i;
  struct desc_struct *p; 

  if (sizeof (struct sigaction) != 16) 
    panic ("Struct sigaction MUST be 16 bytes");
  向gdt中设置任务状态段描述符
  set_tss_desc (gdt + FIRST_TSS_ENTRY, &(init_task.task.tss));
  向gdt总设置局部描述符表的描述符
  set_ldt_desc (gdt + FIRST_LDT_ENTRY, &(init_task.task.ldt));
 
  描述符结构，8字节。
  typedef struct desc_struct
  {
    unsigned long a, b;  
  }desc_table[256];
  一共256项。
  确定描述符标的偏移值。之前设置过tss和第一个ldt的描述符。
  为任务数组清0，将128个描述符表项清0
  p = gdt + 2 + FIRST_TSS_ENTRY;
  for (i = 1; i < NR_TASKS; i++)
    {
      task[i] = NULL;
      p->a = p->b = 0;
      p++;
      p->a = p->b = 0;
      p++;
    }
  清除标志寄存器中的NT标志位，嵌套标志位，如果中断处理程序调用iret指令，就会引起任务切换
  __asm__ ("pushfl ; andl $0xffffbfff,(%esp) ; popfl"); 
  将任务0的任务状态段的选择符加入到任务寄存器中
  ltr (0);   
  将任务0的局部表选择符加载到局部描述符寄存器中。
  lldt (0);   
  初始化定时器。
  outb_p (0x36, 0x43);  
  outb_p (LATCH & 0xff, 0x40); 
  outb (LATCH >> 8, 0x40); 
  set_intr_gate (0x20, &timer_interrupt);
  outb (inb_p (0x21) & ~0x01, 0x21);
  set_system_gate (0x80, &system_call);
}

清风1981
关注
Linux内核0.11版本sched.c中sleep_on()函数分析
r21nn的博客
03-20 1706
void sleep_on(struct task_struct **p)  {      struct task_struct *tmp;        if (!p)   //若指针无效，则退出          return;      if (current == &(init_task.task)) //若当前任务是任务0则死机          panic("task[0
Linux实时调度策略(SCHED_RR)和CFS(SCHED_OTHER)之间的区别
tugouxp的专栏
07-22 3249
本文试图从直观角度，说明SCHED_RR调度策略和SCHED_OTHER调度策略之间的区别。在Linux上，SCHED_OTHER和SCHED_NORMAL的意思相同，它们都是指的CFS调度策略，只不过，在内核中，CFS定义为SCHED_NORMAL，在用户态，CFS定义为SCHED_OTHER.可参照内核头文件和musl libc头文件：代码执行流前首先设置了调度策略为SCHED_OTHER， pthread_attr_setschedpolicy(&attr,SCHED_OTHER);
linux_sched.h
myxmu的专栏
09-06 1493
#ifndef _SCHED_H #define _SCHED_H #define NR_TASKS 64        // 系统中同时最多任务（进程）数。 #define HZ 100            // 定义系统时钟滴答频率(1 百赫兹，每个滴答10ms) #define FIRST_TASK task[0]    // 任务0 比较特殊，所以特意给它单独定义一个符号。 #
linux sched.h
北极鱼
11-02 2738
[cpp] view plaincopy #ifndef _LINUX_SCHED_H   #define _LINUX_SCHED_H      /*   * cloning flags:   */   #define CSIGNAL     0x000000ff  /* signal mask to be sent at exit */   #def
linux进程调度（2） kernel/sched 文件介绍
最新发布
weixin_45705773的博客
08-21 699
调度子系统在 Linux 内核中占据了至关重要的地位，负责管理各种 CPU 资源的分配、进程的执行顺序，以及满足不同应用和用户的需求。目录下的文件实现了调度的各个方面，涵盖了从公平调度、实时调度到 CPU 频率和负载管理等多种技术，确保 Linux 系统的高效性和响应性。
linux1.0操作系统源码剖析 sched.h sched.c
尘的博客
12-12 1554
#ifndef _SCHED_H #define _SCHED_H #define NR_TASKS 64 //系统最多的进程数 #define HZ 100 // 系统时钟频率 100HZ #define FIRST_TASK task[0] //任务0是 比较特殊 init() #define LAST_TASK task[NR_TASKS-1] //任务数组里...
深入解读Linux进程调度系列（2）——调度类sched_class详解
Hugo的博客
04-06 2782
系列文章：https://blog.csdn.net/Vince_/article/details/89054330 调度器的类型 根据任务的资源需求类型可以将其分为IO-bounced和Processor-bounced进程，其中IO-bounced可以较为广义的理解，比如网络设备以及键盘鼠标等，实时性要求较高，但是CPU占用可能并不密集。Processor-bounced进程对CPU的使用...
《linux 内核完全剖析》sched.c sched.h 代码分析笔记
热门推荐
Jason Leaster | Rebuilding the tower of babel
05-07 1万+
首先上header file #ifndef _SCHED_H #define _SCHED_H #define HZ 100 #define NR_TASKS 64 #define TASK_SIZE 0x04000000 #define LIBRARY_SIZE 0x00400000 #if (TASK_SIZE & 0x3fffff) #error "TASK_
pthread.h sched.h semaphore.h 三个头文件
04-22
标题提到的"pthread.h"、"sched.h"和"semaphore.h"是三个在多线程编程和进程调度中常用的头文件，特别是在Linux和类Unix系统中。然而，这里我们看到这些文件在Windows环境下使用Cygwin进行darknet编译时也有所需求。...
linux_sched.zip_Linux进程调度
09-24
"linux_sched.zip"这个压缩包包含了与Linux进程调度相关的源代码，包括"sched.c"、"main.c"、"exit.c"、"fork.c"和"process.c"等文件。这些文件很可能用于实现一个简单的模拟或者分析Linux进程调度机制的工具。 1. ...
Linux内核源码中linux_sched.h的解读
由于linux_sched.h文件涉及的是底层操作系统级别的功能，因此它要求开发者具备深入的Linux内核知识和C语言编程技能。在阅读和修改这些源码时，开发者不仅需要理解调度算法和进程管理的概念，还需要熟悉Linux内核的...
每天分析一段linux内核代码---<linux/sched.h>
viewsky11的专栏
08-13 1974
#ifndef _SCHED_H #define _SCHED_H #define NR_TASKS 64 // 系统中同时最多任务（进程）数。 #define HZ 100 // 定义系统时钟滴答频率(1 百赫兹，每个滴答10ms) #define FIRST_TASK task[0] // 任务0 比较特殊，所以特意给它单独定义一个符号。 #define LAST_TASK task
linux 任务调度 sched_setscheduler
aningxiaoxixi的博客
09-17 1461
我们考虑一种很坏的情况，如果有若干相同优先级的线程等待执行，然而最早执行的线程无终止或者阻塞动作，那么其他线程是无法执行的，除非当前线程调用如pthread_yield之类的函数，所以在使用SCHED_FIFO的时候要小心处理相同级别线程的动作。它是默认的线程分时调度策略，所有的线程的优先级别都是0，线程的调度是通过分时来完成的。请注意，这种调度策略也是抢占式的，当高优先级的线程准备运行的时候，当前线程将被抢占并进入等待队列。这种调度策略仅仅决定线程在可运行线程队列中的具有相同优先级的线程的运行次序。
linux0.11内核完全剖析- sched.c
RunInProgram的博客
11-29 1474
声明： 参考《linux内核完全剖析基于linux0.11》--赵炯    节选 sched.c 程序 1 功能描述 sched.c 是内核中有关任务调度函数的程序，其中包括有关调度的基本函数(sleep_on、 wakeup、schedule 等)以及一些简单的系统调用函数（比如 getpid()）。另外 Linus 为了编程的方便，考虑到软盘驱动器程序定时的需要，也将操作软盘的
linux0.11进程调度详解
sadyjx
05-31 3464
内核调度初始化 sched_init() set_tss_desc() &amp;amp;amp;amp;amp; set_ldt_desc() ltr() &amp;amp;amp;amp;amp; lldt() LATCH 进程调度流程 中断处理函数_timer_interrupt do_timer() 文章写的有些长，把相关的、用到的函数都列出来了，看完应该能对进程调度相关的代码有一定了解 内核调度初始化 ...
Linux内核分析-8/进程的调度
u011011827的博客
07-26 366
进程的调度 之前我们在mykernel中体验了一次进程的调度,调度分为两个过程 1/保存当前进程 2/装载之前进程 和之前的fork exec 有什么区别呢? fork 和exec 只是创造和修改了一个task_struct 结构体,exec后的进程是要调度模块调度才能运行的. 而进程的调度就是保存一个结构体,并装载一个结构体.linux-0.11中的调度//init/main.c init //k
由Linux0.11进程调度小窥内存分段机制
04-09 3585
       内存分段机制的一个主要应用在于实现操作系统的多任务，它为应用程序提供了两个关键抽象：一个独立的逻辑控制流，一个私有的地址空间。本文将针对进程的创建和调度进行分析和实验，从而更深刻的理解分段机制。有关调试环境的建立见前文：从linux0.11引导代码小窥内存分段机制进程调度初始化（sched_init函数）       在引导代码执行结束后，执行序列将跳转到main函数，执行一系列的初
关于linux驱动(应用)程序头文件使用
newtonnl的专栏
05-31 3196
<br />驱动程序：<br /> <br />#include <linux/***.h> 是在linux-2.6.29/include/linux下面寻找源文件。<br />#include <asm/***.h> 是在linux-2.6.29/arch/arm/include/asm下面寻找源文件。<br />#include <mach/***.h> 是在linux-2.6.29/arch/arm/mach-s3c2410/include/mach下面寻找源文件。<br />#include <pl
2.9.1　初始化进程0
qq308845474的博客
10-18 440
2.9.1　初始化进程0 sched_init函数比较难理解的是下面两行： set_tss_desc(gdt?+?FIRST_TSS_ENTRY,&(init_task.task.tss)); set_ldt_desc(gdt?+?FIRST_LDT_ENTRY,&(init_task.task.ldt)); 这两行代码的目的就是要像图2-17表现的那样在GDT中初始化进程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值