SCHED_截止时间运行时超限信号（SIGXCPU）

我正在使用

SCHED_DEADLINE

实现一个rt线程。我正试图捕捉一个

SIGXCPU

-信号， 如果线程超过指定的

sched_运行时

。据我所知，这可以通过设置

SCHED_FLAG\u DL_overflow

-标志来实现。然而，在下面的示例程序中，没有收到任何信号（在第三次迭代中）。根据kernelshark图，线程在到达运行时后将挂起，但不会创建任何信号

我对

SCHED_FLAG\u DL_overflow

-标志的理解是否正确？如果没有，是否有其他方法可以检测线程是否超过指定的运行时，而不测量每次迭代后的时间

我的内核版本是

5.4.3-rt1-1-rt#1 SMP PREEMPT_rt

#include <unistd.h>
#include <linux/unistd.h>
#include <linux/types.h>
#include <pthread.h>
#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <linux/sched.h>

#define gettid() syscall(__NR_gettid)

#define SCHED_DEADLINE  6

/* XXX use the proper syscall numbers */
#ifdef __x86_64__
#define __NR_sched_setattr      314
#define __NR_sched_getattr      315
#endif

#ifdef __i386__
#define __NR_sched_setattr      351
 #define __NR_sched_getattr     352
#endif

#ifdef __arm__
#define __NR_sched_setattr      380
 #define __NR_sched_getattr     381
#endif

static volatile int done;

struct sched_attr {
    __u32 size;

    __u32 sched_policy;
    __u64 sched_flags;

    /* SCHED_NORMAL, SCHED_BATCH */
    __s32 sched_nice;

    /* SCHED_FIFO, SCHED_RR */
    __u32 sched_priority;

    /* SCHED_DEADLINE (nsec) */
    __u64 sched_runtime;
    __u64 sched_deadline;
    __u64 sched_period;
};

int sched_setattr(pid_t pid,
                  const struct sched_attr *attr,
                  unsigned int flags)
{
    return syscall(__NR_sched_setattr, pid, attr, flags);
}

int sched_getattr(pid_t pid,
                  struct sched_attr *attr,
                  unsigned int size,
                  unsigned int flags)
{
    return syscall(__NR_sched_getattr, pid, attr, size, flags);
}


void set_rt(int pid, unsigned long runtime, unsigned long period, unsigned long deadline){
    struct sched_attr attr;
    unsigned int flags = 0;
    attr.size = sizeof(attr);
    attr.sched_flags =  SCHED_FLAG_DL_OVERRUN;
    attr.sched_nice = 0;
    attr.sched_priority = 0;
    attr.sched_policy = SCHED_DEADLINE;
    attr.sched_runtime = runtime;
    attr.sched_period = period;
    attr.sched_deadline = deadline;

    int ret = sched_setattr(pid, &attr, 0);
    if (ret < 0) {
        done = 0;
        perror("sched_setattr");
        exit(-1);
    }

    struct sched_attr param;
    ret = sched_getattr(pid, &param, sizeof(param), 0);
    if (ret < 0) {
        done = 0;
        perror("sched_getattr");
        exit(-1);
    }
}

void sig_handler(int signo)
{
    if (signo == SIGXCPU)
        printf("received SIGXCPU\n");
}

int main (void) {
    printf("MY PID: %d\n", getpid());
    set_rt(gettid(), 500000000Ul, 1000000000Ul, 1000000000Ul);

    struct sigaction s;
    bzero(&s, sizeof(s));
    s.sa_handler = sig_handler;
    sigaction (SIGXCPU, &s, NULL);

    //test signal handler
    kill(getpid(), SIGXCPU);

    int i = 0;
    while (1) {
        i++;
        printf("Loop Number %d\n", i);
        int k = 900000000;
        if (i == 3) {
            while (k > 0) k--;
        }
        sched_yield();
    }
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义gettid（）系统调用（\uuunr\ugettid）
#定义附表6
/*XXX使用正确的系统调用号码*/
#ifdef\uuux86\u64__
#定义\uuuu NR\u sched\u setattr 314
#定义\uuuu NR\u sched\u getattr 315
#恩迪夫
#ifdef__i386__
#定义\uuuu NR\u sched\u setattr 351
#定义\uuuuunr\uSCHED\uGetAttr 352
#恩迪夫
#ifdef_uu臂__
#定义\uuuu NR\u sched\u setattr 380
#定义\uuuuunr\uSCHED\uGetAttr 381
#恩迪夫
静态不稳定int完成；
结构计划属性{
__u32尺寸；
__u32 sched_政策；
__u64 sched_标志；
/*SCHED_正常，SCHED_批次*/
__s32 sched_nice；
/*先遣先出，先遣后出*/
__u32 sched_优先权；
/*计划截止日期（nsec）*/
__u64 sched_运行时；
__u64 sched_截止日期；
__u64 sched_期；
};
int sched_setattr（pid_t pid，
常量结构sched_attr*attr，
无符号整型标志）
{
返回系统调用（uuu NR_usched_usetattr、pid、attr、flags）；
}
int sched_getattr（pid_t pid，
结构sched_attr*attr，
无符号整数大小，
无符号整型标志）
{
返回系统调用（\uuuunr\usched\ugetattr、pid、attr、size、flags）；
}
void set_rt（整数pid、无符号长运行时间、无符号长周期、无符号长截止日期）{
结构sched_attr attr；
无符号整数标志=0；
attr.size=sizeof（attr）；
attr.sched_flags=sched_FLAG_DL_溢出；
attr.sched_nice=0；
attr.sched_优先级=0；
attr.sched_policy=sched_截止日期；
attr.sched_runtime=运行时；
attr.sched_period=期间；
attr.sched_deadline=截止日期；
int-ret=sched_setattr（pid和attr，0）；
如果（ret<0）{
完成=0；
perror（“sched_setattr”）；
出口（-1）；
}
结构sched_attr param；
ret=sched_getattr（pid，¶m，sizeof（param），0）；
如果（ret<0）{
完成=0；
perror（“sched_getattr”）；
出口（-1）；
}
}
无效信号处理器（int signo）
{
if（signo==SIGXCPU）
printf（“收到的SIGXCPU\n”）；
}
内部主（空）{
printf（“我的PID:%d\n”，getpid（））；
设置（getId（），500000000Ul，1000000000Ul，1000000000Ul）；
结构sigs；
bzero（s，sizeof（s））；
s、 sa_handler=sig_handler；
sigaction（SIGXCPU，&s，NULL）；
//测试信号处理器
kill（getpid（），SIGXCPU）；
int i=0；
而(1){
i++；
printf（“循环编号%d\n”，i）；
int k=900000000；
如果（i==3）{
而（k>0）k--；
}
sched_yield（）；
}
}

为什么不将

包括在内？为什么要提供自己对调用和结构的定义？@KamilCuk，我一直在关注这个问题。我的系统上的sched.h标头不包含
sched_setattr（）
等。
sched_FLAG\u reclain
-标志按预期工作，因此我认为这没有问题。