如何在Linux内核里增加一个系统调用？

一、Linux0.11下添加系统调用：

我在bochs2.2.1中对linux0.11内核添加了一个新的系统调用，步骤如下：

1./usr/src/linux/include/unistd.h中添加：#define __NR_mytest 87

然后在下面声明函数原型：int mytest()

2./usr/src/linux/include/linux/sys.h中添加:extern int sys_mytest()

然后在sys_call_table中最后加上sys_mytest；

3.在/usr/src/linux/kernel/sys.c中添加函数实现如下：

int sys_mytest(){

printk("This is a test!")

return 123

}

4.在/usr/src/linux/kernel/system_call.s中对系统调用号加1（原来是86改成了87）

5.然后到/usr/src/linux目录下编译内核make cleanmake Image

6. cp /usr/src/linux/include/unistd.h /usr/include/unistd.h

7. reset bochs

8. 在/usr/root中生成test.c文件如下：

#define __LIBRARY__

#include <unistd.h>

_syscall0(int,mytest)

int main(){

int a

a = mytest()

printf("%d", a)

return 0

}

9.然后gcc test.c编译之后运行a.out，前面所有步骤都通过，但是每次调用都是返回-1，然后我查过errno为1（表示 *** 作不允许），就不知道为什么了？

系统知道的高手们能够告知一下，不胜感激！这个问题困扰我很久了！

二、新Linux内核添加系统调用

如何在Linux系统中添加新的系统调用

系统调用是应用程序和 *** 作系统内核之间的功能接口。其主要目的是使得用户可以使用 *** 作系统提供的有关设备管理、输入/输入系统、文件系统和进程控制、通信以及存储管理等方面的功能，而不必了解系统程序的内部结构和有关硬件细节，从而起到减轻用户负担和保护系统以及提高资源利用率的作用。

Linux *** 作系统作为自由软件的代表，它优良的性能使得它的应用日益广泛，不仅得到专业人士的肯定，而且商业化的应用也是如火如荼。在Linux中，大部分的系统调用包含在Linux的libc库中，通过标准的C函数调用方法可以调用这些系统调用。那么，对Linux的发烧友来说，如何在Linux中增加新的系统调用呢？

1 Linux系统调用机制

在Linux系统中，系统调用是作为一种异常类型实现的。它将执行相应的机器代码指令来产生异常信号。产生中断或异常的重要效果是系统自动将用户态切换为核心态来对它进行处理。这就是说，执行系统调用异常指令时，自动地将系统切换为核心态，并安排异常处理程序的执行。Linux用来实现系统调用异常的实际指令是：

Int $0x80

这一指令使用中断/异常向量号128（即16进制的80）将控制权转移给内核。为达到在使用系统调用时不必用机器指令编程，在标准的C语言库中为每一系统调用提供了一段短的子程序，完成机器代码的编程工作。事实上，机器代码段非常简短。它所要做的工作只是将送给系统调用的参数加载到CPU寄存器中，接着执行int $0x80指令。然后运行系统调用，系统调用的返回值将送入CPU的一个寄存器中，标准的库子程序取得这一返回值，并将它送回用户程序。

为使系统调用的执行成为一项简单的任务，Linux提供了一组预处理宏指令。它们可以用在程序中。这些宏指令取一定的参数，然后扩展为调用指定的系统调用的函数。

这些宏指令具有类似下面的名称格式：

_syscallN（parameters）

其中N是系统调用所需的参数数目，而parameters则用一组参数代替。这些参数使宏指令完成适合于特定的系统调用的扩展。例如，为了建立调用setuid（）系统调用的函数，应该使用：

_syscall1（ int， setuid， uid_t， uid ）

syscallN（ ）宏指令的第1个参数int说明产生的函数的返回值的类型是整型，第2个参数setuid说明产生的函数的名称。后面是系统调用所需要的每个参数。这一宏指令后面还有两个参数uid_t和uid分别用来指定参数的类型和名称。

另外，用作系统调用的参数的数据类型有一个限制，它们的容量不能超过四个字节。这是因为执行int $0x80指令进行系统调用时，所有的参数值都存在32位的CPU寄存器中。使用CPU寄存器传递参数带来的另一个限制是可以传送给系统调用的参数的数目。这个限制是最多可以传递5个参数。所以Linux一共定义了6个不同的_syscallN（）宏指令，从_syscall0（）、_syscall1（）直到_syscall5（）。

一旦_syscallN（）宏指令用特定系统调用的相应参数进行了扩展，得到的结果是一个与系统调用同名的函数，它可以在用户程序中执行这一系统调用。

2 添加新的系统调用

如果用户在Linux中添加新的系统调用，应该遵循几个步骤才能添加成功，下面几个步骤详细说明了添加系统调用的相关内容。

（1） 添加源代码

第一个任务是编写加到内核中的源程序，即将要加到一个内核文件中去的一个函数，该函数的名称应该是新的系统调用名称前面加上sys_标志。假设新加的系统调用为mycall(int number)，在/usr/src/linux/kernel/sys.c文件中添加源代码，如下所示：

asmlinkage int sys_mycall(int number)

{

return number

}

作为一个最简单的例子，我们新加的系统调用仅仅返回一个整型值。

（2） 连接新的系统调用

添加新的系统调用后，下一个任务是使Linux内核的其余部分知道该程序的存在。为了从已有的内核程序中增加到新的函数的连接，需要编辑两个文件。

在我们所用的Linux内核版本（RedHat 6.0，内核为2.2.5-15）中，第一个要修改的文件是：

/usr/src/linux/include/asm-i386/unistd.h

该文件中包含了系统调用清单，用来给每个系统调用分配一个唯一的号码。文件中每一行的格式如下：

#define __NR_name NNN

其中，name用系统调用名称代替，而NNN则是该系统调用对应的号码。应该将新的系统调用名称加到清单的最后，并给它分配号码序列中下一个可用的系统调用号。我们的系统调用如下：

#define __NR_mycall 191

系统调用号为191，之所以系统调用号是191，是因为Linux-2.2内核自身的系统调用号码已经用到190。

第二个要修改的文件是：

/usr/src/linux/arch/i386/kernel/entry.S

该文件中有类似如下的清单：

.long SYMBOL_NAME（）

该清单用来对sys_call_table[]数组进行初始化。该数组包含指向内核中每个系统调用的指针。这样就在数组中增加了新的内核函数的指针。我们在清单最后添加一行：

.long SYMBOL_NAME(sys_mycall)

（3） 重建新的Linux内核

为使新的系统调用生效，需要重建Linux的内核。这需要以超级用户身份登录。

#pwd

/usr/src/linux

#

超级用户在当前工作目录（/usr/src/linux）下，才可以重建内核。

#make config

#make dep

#make clearn

#make bzImage

编译完毕后，系统生成一可用于安装的、压缩的内核映象文件：

/usr/src/linux/arch/i386/boot/bzImage

（4） 用新的内核启动系统

要使用新的系统调用，需要用重建的新内核重新引导系统。为此，需要修改/etc/lilo.conf文件，在我们的系统中，该文件内容如下：

boot=/dev/hda

map=/boot/map

install=/boot/boot.b

prompt

timeout=50

image=/boot/vmlinuz-2.2.5-15

label=linux

root=/dev/hdb1

　 read-only

other=/dev/hda1

label=dos

table=/dev/had

首先编辑该文件，添加新的引导内核：

image=/boot/bzImage-new

label=linux-new

root=/dev/hdb1

read-only

添加完毕，该文件内容如下所示：

boot=/dev/hda

map=/boot/map

install=/boot/boot.b

prompt

timeout=50

image=/boot/bzImage-new

label=linux-new

root=/dev/hdb1

read-only

image=/boot/vmlinuz-2.2.5-15

label=linux

root=/dev/hdb1

read-only

other=/dev/hda1

label=dos

table=/dev/hda

这样，新的内核映象bzImage-new成为缺省的引导内核。为了使用新的lilo.conf配置文件，还应执行下面的命令：

#cp /usr/src/linux/arch/i386/boot/zImage /boot/bzImage-new

其次配置lilo:

# /sbin/lilo

现在，当重新引导系统时，在boot:提示符后面有三种选择：linux-new 、linux、dos，新内核成为缺省的引导内核。

至此，新的Linux内核已经建立，新添加的系统调用已成为 *** 作系统的一部分，重新启动Linux，用户就可以在应用程序中使用该系统调用了。

（5）使用新的系统调用

在应用程序中使用新添加的系统调用mycall。同样为实验目的，我们写了一个简单的例子xtdy.c。

/* xtdy.c */

#include

_syscall1(int,mycall,int,ret)

main()

{

printf("%d \n",mycall(100))

}

编译该程序：

# cc -o xtdy xtdy.c

执行：

# xtdy

结果：

# 100

注意，由于使用了系统调用，编译和执行程序时，用户都应该是超级用户身份。

《linux内核设计与实现》读书笔记（五）-系统调用主要内容：什么是系统调用linux上的系统调用实现原理一个简单的系统调用的实现1ernel/sys.c我在sys.c中追加了2个函数:sys_foo和sys_bar如果是在x86_64的内核中增加一个系统调用，只需修改 arch/x86/include/asm/unistd_64.h，比如sys_bar。修改内容参见下面的diff文件：diff -r new/arch/x86/ia32/ia32entry.S old/arch/x86/ia32/ia32entry.S855d854< .quad sys_foodiff -r new/arch/x86/include/asm/unistd_32.h old/arch/x86/include/asm/unistd_32.h357d356<#define __NR_foo 349361c360<#define NR_syscalls 350--- >#define NR_syscalls 349diff -r new/arch/x86/include/asm/unistd_64.h old/arch/x86/include/asm/unistd_64.h689,692d688<#define __NR_foo 312<__SYSCALL(__NR_foo, sys_foo)<#define __NR_bar 313<__SYSCALL(__NR_bar, sys_bar)diff -r new/arch/x86/kernel/syscall_table_32.S old/arch/x86/kernel/syscall_table_32.S351d350< .long sys_foodiff -r new/include/asm-generic/unistd.h old/include/asm-generic/unistd.h694,695d693<#define __NR_foo 272<__SYSCALL(__NR_foo, sys_foo)698c696<#define __NR_syscalls 273--->#define __NR_syscalls 272diff -r new/kernel/sys.c old/kernel/sys.c1920,1928d1919<<asmlinkage long sys_foo(void)<{< return 1112223334444555<}<asmlinkage long sys_bar(void)<{< return 1234567890<} 3.3 编译内核#cd linux-3.2.28#make menuconfig (选择要编译参数，如果不熟悉内核编译，用默认选项即可)#make all (这一步真的时间很长......)#make modules_install#make install (这一步会把新的内核加到启动项中)#reboot (重启系统进入新的内核)3.4 编写调用的系统调用的代码#include <unistd.h>#include <sys/syscall.h>#include <string.h>#include <stdio.h>#include <errno.h>#define __NR_foo 312#define __NR_bar 313 int main(){printf (result foo is %ld/n, syscall(__NR_foo)) printf(%s/n, strerror(errno)) printf (result bar is %ld/n, syscall(__NR_bar)) printf(%s/n, strerror(errno)) return 0}编译运行上面的代码：#gcc test.c -o test#./test运行结果如下：result foo is 1112223334444555Successresult bar is 1234567890Success

1.调度器的概述

多任务 *** 作系统分为非抢占式多任务和抢占式多任务。与大多数现代 *** 作系统一样，Linux采用的是抢占式多任务模式。这表示对CPU的占用时间由 *** 作系统决定的，具体为 *** 作系统中的调度器。调度器决定了什么时候停止一个进程以便让其他进程有机会运行，同时挑选出一个其他的进程开始运行。

2.调度策略

在Linux上调度策略决定了调度器是如何选择一个新进程的时间。调度策略与进程的类型有关，内核现有的调度策略如下：

#define SCHED_NORMAL        0#define SCHED_FIFO      1#define SCHED_RR        2#define SCHED_BATCH     3/* SCHED_ISO: reserved but not implemented yet */#define SCHED_IDLE      5

0: 默认的调度策略，针对的是普通进程。

1：针对实时进程的先进先出调度。适合对时间性要求比较高但每次运行时间比较短的进程。

2：针对的是实时进程的时间片轮转调度。适合每次运行时间比较长得进程。

3：针对批处理进程的调度，适合那些非交互性且对cpu使用密集的进程。

SCHED_ISO：是内核的一个预留字段，目前还没有使用

5：适用于优先级较低的后台进程。

注：每个进程的调度策略保存在进程描述符task_struct中的policy字段

3.调度器中的机制

内核引入调度类（struct sched_class）说明了调度器应该具有哪些功能。内核中每种调度策略都有该调度类的一个实例。（比如：基于公平调度类为：fair_sched_class，基于实时进程的调度类实例为：rt_sched_class），该实例也是针对每种调度策略的具体实现。调度类封装了不同调度策略的具体实现，屏蔽了各种调度策略的细节实现。

调度器核心函数schedule()只需要调用调度类中的接口，完成进程的调度，完全不需要考虑调度策略的具体实现。调度类连接了调度函数和具体的调度策略。

武特师兄关于sche_class和sche_entity的解释，一语中的。

调度类就是代表的各种调度策略，调度实体就是调度单位，这个实体通常是一个进程，但是自从引入了cgroup后，这个调度实体可能就不是一个进程了，而是一个组

4.schedule()函数

linux 支持两种类型的进程调度，实时进程和普通进程。实时进程采用SCHED_FIFO 和SCHED_RR调度策略，普通进程采用SCHED_NORMAL策略。

preempt_disable()：禁止内核抢占

cpu_rq（）：获取当前cpu对应的就绪队列。

prev = rq->curr获取当前进程的描述符prev

switch_count = &prev->nivcsw获取当前进程的切换次数。

update_rq_clock() ：更新就绪队列上的时钟

clear_tsk_need_resched()清楚当前进程prev的重新调度标志。

deactive_task():将当前进程从就绪队列中删除。

put_prev_task() :将当前进程重新放入就绪队列

pick_next_task():在就绪队列中挑选下一个将被执行的进程。

context_switch():进行prev和next两个进程的切换。具体的切换代码与体系架构有关，在switch_to()中通过一段汇编代码实现。

post_schedule():进行进程切换后的后期处理工作。

5.pick_next_task函数

选择下一个将要被执行的进程无疑是一个很重要的过程，我们来看一下内核中代码的实现

对以下这段代码说明：

1.当rq中的运行队列的个数(nr_running)和cfs中的nr_runing相等的时候，表示现在所有的都是普通进程，这时候就会调用cfs算法中的pick_next_task(其实是pick_next_task_fair函数)，当不相等的时候，则调用sched_class_highest(这是一个宏，指向的是实时进程)，这下面的这个for()循环中，首先是会在实时进程中选取要调度的程序（p = class->pick_next_task(rq)）。如果没有选取到，会执行class=class->next在class这个链表中有三种类型（fair,idle,rt）.也就是说会调用到下一个调度类。

static inline struct task_struct *pick_next_task(struct rq *rq){    const struct sched_class *class   struct task_struct *p   /*

    * Optimization: we know that if all tasks are in

    * the fair class we can call that function directly:

    *///基于公平调度的普通进程

   if (likely(rq->nr_running == rq->cfs.nr_running)) {

       p = fair_sched_class.pick_next_task(rq)       if (likely(p))            return p

   }//基于实时调度的实时进程

   class = sched_class_highest   for ( ) {

       p = class->pick_next_task(rq) //实时进程的类

       if (p)            return p       /*

        * Will never be NULL as the idle class always

        * returns a non-NULL p:

        */

       class = class->next //rt->next = fair fair->next = idle

   }

}

在这段代码中体现了Linux所支持的两种类型的进程，实时进程和普通进程。回顾下：实时进程可以采用SCHED_FIFO 和SCHED_RR调度策略，普通进程采用SCHED_NORMAL调度策略。

在这里首先说明一个结构体struct rq,这个结构体是调度器管理可运行状态进程的最主要的数据结构。每个cpu上都有一个可运行的就绪队列。刚才在pick_next_task函数中看到了在选择下一个将要被执行的进程时实际上用的是struct rq上的普通进程的调度或者实时进程的调度，那么具体是如何调度的呢？在实时调度中，为了实现O(1)的调度算法，内核为每个优先级维护一个运行队列和一个DECLARE_BITMAP,内核根据DECLARE_BITMAP的bit数值找出非空的最高级优先队列的编号，从而可以从非空的最高级优先队列中取出进程进行运行。

我们来看下内核的实现

struct rt_prio_array {

   DECLARE_BITMAP(bitmap, MAX_RT_PRIO+1)/* include 1 bit for delimiter */

   struct list_head queue[MAX_RT_PRIO]

}

数组queue[i]里面存放的是优先级为i的进程队列的链表头。在结构体rt_prio_array 中有一个重要的数据构DECLARE_BITMAP，它在内核中的第一如下：

define DECLARE_BITMAP(name,bits) \

   unsigned long name[BITS_TO_LONGS(bits)]

5.1对于实时进程的O(1)算法

这个数据是用来作为进程队列queue[MAX_PRIO]的索引位图。bitmap中的每一位与queue[i]对应，当queue[i]的进程队列不为空时，Bitmap的相应位就为1，否则为0，这样就只需要通过汇编指令从进程优先级由高到低的方向找到第一个为1的位置，则这个位置就是就绪队列中最高的优先级（函数sched_find_first_bit()就是用来实现该目的的）。那么queue[index]->next就是要找的候选进程。

如果还是不懂，那就来看两个图

注：在每个队列上的任务一般基于先进先出的原则进行调度（并且为每个进程分配时间片）

在内核中的实现为：

static struct sched_rt_entity *pick_next_rt_entity(struct rq *rq,                           struct rt_rq *rt_rq){    struct rt_prio_array *array = &rt_rq->active   struct sched_rt_entity *next = NULL   struct list_head *queue   int idx

   idx = sched_find_first_bit(array->bitmap)//找到优先级最高的位

   BUG_ON(idx >= MAX_RT_PRIO)   queue = array->queue + idx//然后找到对应的queue的起始地址

   next = list_entry(queue->next, struct sched_rt_entity, run_list) //按先进先出拿任务

   return next

}

那么当同一优先级的任务比较多的时候，内核会根据

位图：

将对应的位置为1，每次取出最大的被置为1的位，表示优先级最高：

5.2 关于普通进程的CFS算法：

我们知道，普通进程在选取下一个需要被调度的进程时，是调用的pick_next_task_fair函数。在这个函数中是以调度实体为单位进行调度的。其最主要的函数是：pick_next_entity，在这个函数中会调用wakeup_preempt_entity函数，这个函数的主要作用是根据进程的虚拟时间以及权重的结算进程的粒度，以判断其是否需要抢占。看一下内核是怎么实现的：

wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se)

{

   s64 gran, vdiff = curr->vruntime - se->vruntime//计算两个虚拟时间差//如果se的虚拟时间比curr还大，说明本该curr执行，无需抢占

   if (vdiff <= 0)        return -1

   gran = wakeup_gran(curr, se)   if (vdiff >gran)        return 1   return 0

}

gran为需要抢占的时间差，只有两个时间差大于需要抢占的时间差，才需要抢占，这里避免太频繁的抢占

wakeup_gran(struct sched_entity *curr, struct sched_entity *se)

{

   unsigned long gran = sysctl_sched_wakeup_granularity   if (cfs_rq_of(curr)->curr &&sched_feat(ADAPTIVE_GRAN))

       gran = adaptive_gran(curr, se)

   /*

    * Since its curr running now, convert the gran from real-time

    * to virtual-time in his units.

    */    if (sched_feat(ASYM_GRAN)) {

       /*

        * By using 'se' instead of 'curr' we penalize light tasks, so

        * they get preempted easier. That is, if 'se' <'curr' then

        * the resulting gran will be larger, therefore penalizing the

        * lighter, if otoh 'se' >'curr' then the resulting gran will

        * be smaller, again penalizing the lighter task.

        *

        * This is especially important for buddies when the leftmost

        * task is higher priority than the buddy.

        */        if (unlikely(se->load.weight != NICE_0_LOAD))

           gran = calc_delta_fair(gran, se)

   } else {        if (unlikely(curr->load.weight != NICE_0_LOAD))

           gran = calc_delta_fair(gran, curr)

   }    return gran

}

6.调度中的nice值

首先需要明确的是：nice的值不是进程的优先级，他们不是一个概念，但是进程的Nice值会影响到进程的优先级的变化。

通过命令ps -el可以看到进程的nice值为NI列。PRI表示的是进程的优先级，其实进程的优先级只是一个整数，它是调度器选择进程运行的基础。

普通进程有：静态优先级和动态优先级。

静态优先级：之所有称为静态优先级是因为它不会随着时间而改变，内核不会修改它，只能通过系统调用nice去修改,静态优先级用进程描述符中的static_prio来表示。在内核中/kernel/sched.c中，nice和静态优先级的关系为：

#define NICE_TO_PRIO(nice)  (MAX_RT_PRIO + (nice) + 20)

#define PRIO_TO_NICE(prio)  ((prio) - MAX_RT_PRIO - 20)

动态优先级：调度程序通过增加或者减小进程静态优先级的值来奖励IO小的进程或者惩罚cpu消耗型的进程。调整后的优先级称为动态优先级。在进程描述中用prio来表示，通常所说的优先级指的是动态优先级。

由上面分析可知，我们可以通过系统调用nice函数来改变进程的优先级。

#include <stdlib.h>#include <stdio.h>#include <math.h>#include <unistd.h>#include <sys/time.h>#define JMAX (400*100000)#define GET_ELAPSED_TIME(tv1,tv2) ( \

 (double)( (tv2.tv_sec - tv1.tv_sec) \

           + .000001 * (tv2.tv_usec - tv1.tv_usec)))//做一个延迟的计算double do_something (void){    int j   double x = 0.0   struct timeval tv1, tv2

   gettimeofday (&tv1, NULL)//获取时区

   for (j = 0j <JMAXj++)

       x += 1.0 / (exp ((1 + x * x) / (2 + x * x)))

   gettimeofday (&tv2, NULL)   return GET_ELAPSED_TIME (tv1, tv2)//求差值}int main (int argc, char *argv[]){    int niceval = 0, nsched   /* for kernels less than 2.6.21, this is HZ

      for tickless kernels this must be the MHZ rate

      e.g, for 2.6 GZ scale = 2600000000 */

   long scale = 1000   long ticks_cpu, ticks_sleep   pid_t pid

   FILE *fp   char fname[256]   double elapsed_time, timeslice, t_cpu, t_sleep   if (argc >1)

       niceval = atoi (argv[1])

   pid = getpid ()   if (argc >2)

       scale = atoi (argv[2])   /* give a chance for other tasks to queue up */

   sleep (3)   sprintf (fname, "/proc/%d/schedstat", pid)//读取进程的调度状态

   /*

       在schedstat中的数字是什么意思呢？：

   */

   /*    printf ("Fname = %s\n", fname)*/

   if (!(fp = fopen (fname, "r"))) {        printf ("Failed to open stat file\n")       exit (-1)

   }    //nice系统调用

   if (nice (niceval) == -1 &&niceval != -1) {        printf ("Failed to set nice to %d\n", niceval)       exit (-1)

   }

   elapsed_time = do_something ()//for 循环执行了多长时间

   fscanf (fp, "%ld %ld %d", &ticks_cpu, &ticks_sleep, &nsched)//nsched表示调度的次数

   t_cpu = (float)ticks_cpu / scale//震动的次数除以1000，就是时间

   t_sleep = (float)ticks_sleep / scale

   timeslice = t_cpu / (double)nsched//除以调度的次数，就是每次调度的时间（时间片）

   printf ("\nnice=%3d time=%8g secs pid=%5d"

           "  t_cpu=%8g  t_sleep=%8g  nsched=%5d"

           "  avg timeslice = %8g\n",

           niceval, elapsed_time, pid, t_cpu, t_sleep, nsched, timeslice)

   fclose (fp)   exit (0)

}

说明： 首先说明的是/proc/[pid]/schedstat:在这个文件下放着3个变量，他们分别代表什么意思呢？

第一个：该进程拥有的cpu的时间

第二个：在对列上的等待时间，即睡眠时间

第三个：被调度的次数

由结果可以看出当nice的值越小的时候，其睡眠时间越短，则表示其优先级升高了。

7.关于获取和设置优先级的系统调用：sched_getscheduler（）和sched_setscheduler

#include <sched.h>#include <stdlib.h>#include <stdio.h>#include <errno.h>#define DEATH(mess) { perror(mess)exit(errno)}void printpolicy (int policy){    /* SCHED_NORMAL = SCHED_OTHER in user-space */

   if (policy == SCHED_OTHER)        printf ("policy = SCHED_OTHER = %d\n", policy)   if (policy == SCHED_FIFO)        printf ("policy = SCHED_FIFO = %d\n", policy)   if (policy == SCHED_RR)        printf ("policy = SCHED_RR = %d\n", policy)

}int main (int argc, char **argv){    int policy   struct sched_param p   /* obtain current scheduling policy for this process */

   //获取进程调度的策略

   policy = sched_getscheduler (0)

   printpolicy (policy)   /* reset scheduling policy */

   printf ("\nTrying sched_setscheduler...\n")

   policy = SCHED_FIFO

   printpolicy (policy)

   p.sched_priority = 50   //设置优先级为50

   if (sched_setscheduler (0, policy, &p))

       DEATH ("sched_setscheduler:")   printf ("p.sched_priority = %d\n", p.sched_priority)   exit (0)

}

输出结果：

[root@wang schedule]# ./get_schedule_policy policy = SCHED_OTHER = 0

Trying sched_setscheduler...

policy = SCHED_FIFO = 1

p.sched_priority = 50

可以看出进程的优先级已经被改变。

---