Linux内核编程实验三。。。。。

Question

问题 A
使用ITIMER_REAL型定时器实现一个gettimeofday()，将它设置为每秒产生一个信号，
并计算已经经过的秒数。
问题 B
使用以上实现的 gettimeofday()实现一个精确到微秒级的“闹钟”。
问题 C
实现以上一个父进程和两个子进程并发递归计算不同项数的fibonacci序列的程序，
分析每个进程三种类型定时器测出的时间关系。

#include
#include
#include
#include
#include //for time()
#include //for itimeval
#include //for pid_t
#include //for waitpid

void psig_real(int signum); //父进程3个信号处理函数
void psig_virtual(int signum);
void psig_prof(int signum);
void c1sig_real(int signum); //子进程1的3个信号处理
void c1sig_virtual(int signum);
void c1sig_prof(int signum);
void c2sig_real(int signum); //子进程2的3个信号处理
void c2sig_virtual(int signum);
void c2sig_prof(int signum);

long fibonacci(unsigned int n); //求斐波那契

//记时变量
long p_real_secs=0,c1_real_secs=0,c2_real_secs=0;
long p_virtual_secs=0,c1_virtual_secs=0,c2_virtual_secs=0;
long p_prof_secs= 0,c1_prof_secs=0, c2_prof_secs=0;

//计时器结构体
struct itimerval p_realt, c1_realt, c2_realt;
struct itimerval p_virtt, c1_virtt, c2_virtt;
struct itimerval p_proft, c1_proft, c2_proft;

//part A的信号处理
void psig_real_gettime(int signum)
{
p_real_secs += 1;
}

//实现具有gettimeofday功能 ，接收一个函数
void mygettimeofday(unsigned int i,long (*timefunction)(unsigned int))
{
signal(SIGALRM,psig_real_gettime);
p_realt.it_value.tv_sec = 0; //0 sec
p_realt.it_value.tv_usec = 999999; //999999 usec
p_realt.it_interval.tv_sec = 0;
p_realt.it_interval.tv_usec = 999999;
setitimer(ITIMER_REAL,&p_realt,NULL);
timefunction(i);
getitimer(ITIMER_REAL,&p_realt);
printf("cost time %ld Sec : %ld Msec\n",
p_real_secs,
(999999 - p_realt.it_value.tv_usec) / 1000);
}

int wakeupme = 0; //part B闹钟

void dealalarm(int signum) //闹钟处理函数
{
wakeupme = 1;
}

int main(int argc,char **argv)
{
long fib = 0, microsecond;
pid_t pid1, pid2;
int msecond, usecond;
struct timeval tv;
if(argv[1][0] == '-' && argv[1][1] == 'a' && argc == 3)
{
printf("-----PART A-----\n");
mygettimeofday(atoi(argv[2]),fibonacci);
return 0;
}

else if(argv[1][0] == '-' && argv[1][1] == 'b')
{
    printf("-----PART B-----\n");
struct timeval tv;
gettimeofday(&tv, NULL);
struct tm *tmptime;
tmptime = localtime(&tv.tv_sec);
printf("now time > %d-%d-%d %d:%d:%d:%d:%d\n",tmptime->tm_year+1900,tmptime->tm_mon+1,tmptime->tm_mday,tmptime->tm_hour,tmptime->tm_min,tmptime->tm_sec,(int)tv.tv_usec/1000,(int)tv.tv_usec%1000);

struct tm inputtime;
int year, month, day, hour, minute, second;
printf("set alarm : ");
scanf("%d-%d-%d %d:%d:%d:%d:%d",&year,&month,&day,&hour, &minute,&second,&msecond,&usecond);
      inputtime.tm_year = year - 1900;
          inputtime.tm_mon = month - 1;
          inputtime.tm_mday = day;
          inputtime.tm_hour = hour;
          inputtime.tm_min = minute;
          inputtime.tm_sec = second;
          inputtime.tm_isdst = 0;
          inputtime.tm_wday = 0;
          inputtime.tm_yday = 0;
microsecond = mktime(&inputtime) * 1000000 +
                  msecond * 1000 + usecond;
microsecond -= tv.tv_sec * 1000000 + tv.tv_usec;
signal(SIGALRM,dealalarm);

    p_realt.it_value.tv_sec = microsecond / 1000000;

    p_realt.it_value.tv_usec = microsecond % 1000000;

    p_realt.it_interval.tv_sec = 0;

    p_realt.it_interval.tv_usec = 0;

    setitimer(ITIMER_REAL,&p_realt,NULL);
while(!wakeupme);
printf("wake time > %d-%d-%d %d:%d:%d:%d:%d\n",inputtime.tm_year+1900,inputtime.tm_mon+1,inputtime.tm_mday,inputtime.tm_hour,inputtime.tm_min,inputtime.tm_sec,msecond,usecond);

return 0;

}

else if(argv[1][0] == '-' && argv[1][1] == 'c' && argc == 5)

{

    printf("-----PART C-----\n");

    //bind signal and function for parent process

    signal(SIGALRM,psig_real);

    signal(SIGVTALRM,psig_virtual);

    signal(SIGPROF,psig_prof);

    //init parent process 3 timer

    p_realt.it_interval.tv_sec = 9;

    p_realt.it_interval.tv_usec = 999999;

    p_realt.it_value.tv_sec = 9;

    p_realt.it_value.tv_usec = 999999;

    setitimer(ITIMER_REAL,&p_realt,NULL);



    p_virtt.it_interval.tv_sec = 9;

    p_virtt.it_interval.tv_usec = 999999;

    p_virtt.it_value.tv_sec = 9;

    p_virtt.it_value.tv_usec = 999999;

    setitimer(ITIMER_VIRTUAL,&p_virtt,NULL);



    p_proft.it_interval.tv_sec = 9;

    p_proft.it_interval.tv_usec = 999999;

    p_proft.it_value.tv_sec = 9;

    p_proft.it_value.tv_usec = 999999;

    setitimer(ITIMER_PROF,&p_proft,NULL);



    pid1 = fork();

    if(pid1==0)

    {

    //bind signal and function for child1 process

    signal(SIGALRM,c1sig_real);

    signal(SIGVTALRM,c1sig_virtual);

    signal(SIGPROF,c1sig_prof);

    //init child1 process 3 timer

    c1_realt.it_interval.tv_sec = 0;

    c1_realt.it_interval.tv_usec = 999999;

    c1_realt.it_value.tv_sec = 0;

    c1_realt.it_value.tv_usec = 999999;

    setitimer(ITIMER_REAL,&c1_realt,NULL);





    c1_virtt.it_interval.tv_sec = 0;

    c1_virtt.it_interval.tv_usec = 999999;

    c1_virtt.it_value.tv_sec = 0;

    c1_virtt.it_value.tv_usec = 999999;

    setitimer(ITIMER_VIRTUAL,&c1_virtt,NULL);



    c1_proft.it_interval.tv_sec = 0;

    c1_proft.it_interval.tv_usec = 999999;

    c1_proft.it_value.tv_sec = 0;

    c1_proft.it_value.tv_usec = 999999;

    setitimer(ITIMER_PROF,&c1_proft,NULL);

    //get fibonacci

    fib = fibonacci(atoi(argv[2]));

    //get child1 3 time and fibnacci

    printf("Child1 fib = %ld\n", fib);

    getitimer(ITIMER_REAL,&c1_realt);

    printf("Child1 Real Time = %ld Sec : %ld Msec\n", c1_real_secs + 9-c1_realt.it_value.tv_sec,(999999-c1_realt.it_value.tv_usec)/1000);

    getitimer(ITIMER_VIRTUAL,&c1_virtt);

    printf("Child1 Virtual Time = %ld Sec : %ld Msec\n",c1_virtual_secs + 9-c1_virtt.it_value.tv_sec,(999999-c1_virtt.it_value.tv_usec)/1000);

    getitimer(ITIMER_PROF,&c1_proft);

    printf("Child1 Prof Time = %ld Sec : %ld Msec\n",c1_prof_secs + 9-c1_proft.it_value.tv_sec,(999999-c1_proft.it_value.tv_usec)/1000);

    exit(0);

    }

    else if((pid2=fork()) == 0)

    {

    //bind signal and function for child2 process

    signal(SIGALRM,c2sig_real);

    signal(SIGVTALRM,c2sig_virtual);

    signal(SIGPROF,c2sig_prof);

    //init child2 process 3 timer

    c2_realt.it_interval.tv_sec = 9;

    c2_realt.it_interval.tv_usec = 999999;

    c2_realt.it_value.tv_sec = 9;

    c2_realt.it_value.tv_usec = 999999;

    setitimer(ITIMER_REAL,&c2_realt,NULL);





    c2_virtt.it_interval.tv_sec = 9;

    c2_virtt.it_interval.tv_usec = 999999;

    c2_virtt.it_value.tv_sec = 9;

    c2_virtt.it_value.tv_usec = 999999;

    setitimer(ITIMER_VIRTUAL,&c2_virtt,NULL);



    c2_proft.it_interval.tv_sec = 9;

    c2_proft.it_interval.tv_usec = 999999;

    c2_proft.it_value.tv_sec = 9;

    c2_proft.it_value.tv_usec = 999999;

    setitimer(ITIMER_PROF,&c2_proft,NULL);

    //get fibonacci

    fib = fibonacci(atoi(argv[3]));

    //get child2 3 time and fibnacci

    printf("Child2 fib = %ld\n", fib);

    getitimer(ITIMER_REAL,&c2_realt);

    printf("Child2 Real Time = %ld Sec : %ld Msec\n",c2_real_secs+9-c2_realt.it_value.tv_sec,(999999-c2_realt.it_value.tv_usec)/ 1000);

    getitimer(ITIMER_VIRTUAL,&c2_virtt);

    printf("Child2 Virtual Time = %ld Sec : %ld Msec\n",c2_virtual_secs+9-c2_virtt.it_value.tv_sec,(999999-c2_virtt.it_value.tv_usec)/1000);

    getitimer(ITIMER_PROF,&c2_proft);

    printf("Child2 Prof Time = %ld Sec : %ld Msec\n",c2_prof_secs+9-c2_proft.it_value.tv_sec,(999999-c2_proft.it_value.tv_usec)/ 1000);

    exit(0);

    }

    else

    {

    //get fibonacci

    fib = fibonacci(atoi(argv[4]));

    //print parent 3 time and fibnacci

    printf("Parent fib = %ld\n", fib);

    getitimer(ITIMER_REAL,&p_realt);

    printf("Parent Real Time = %ld Sec : %ld Msec\n",

           p_real_secs + 9 - p_realt.it_value.tv_sec,

           (999999 - p_realt.it_value.tv_usec) / 1000);

    getitimer(ITIMER_VIRTUAL,&p_virtt);

    printf("Parent Virtual Time = %ld Sec : %ld Msec\n",

           p_virtual_secs + 9 - p_virtt.it_value.tv_sec,

           (999999 - p_virtt.it_value.tv_usec) / 1000);

    getitimer(ITIMER_PROF,&p_proft);

    printf("Parent Prof Time = %ld Sec : %ld Msec\n",

           p_prof_secs + 9 - p_proft.it_value.tv_sec,

           (999999 - p_proft.it_value.tv_usec) / 1000);

    //wait child process

    waitpid(pid1,NULL,0);

    waitpid(pid2,NULL,0);

    }

}

}

//parent process signal function

void psig_real(int signum)

{

p_real_secs += 10;

}

void psig_virtual(int signum)

{

p_virtual_secs += 10;

}

void psig_prof(int signum)

{

p_prof_secs += 10;

}

//child1 process signal function

void c1sig_real(int signum)

{

c1_real_secs += 10;

}

void c1sig_virtual(int signum)

{

c1_virtual_secs += 10;

}

void c1sig_prof(int signum)

{

c1_prof_secs += 10;

}

//child2 process signal function

void c2sig_real(int signum)

{

c2_real_secs += 10;

}

void c2sig_virtual(int signum)

{

c2_virtual_secs += 10;

}

void c2sig_prof(int signum)

{

c2_prof_secs += 10;

}

//get fibonacci by n

long fibonacci(unsigned int n)

{

if(n == 1 || n == 2)

    return 1;

return fibonacci(n-1)+fibonacci(n-2);

}

题目要求和代码如上，在Ubuntu上编译运行后报段错误，请问该如何修改？

Answer 1

在LINUX上运行即可解决问题
LINUX：
Linux是一套免费使用和自由传播的类Unix操作系统，是一个基于POSIX和UNIX的多用户、多任务、支持多线程和多CPU的操作系统。它能运行主要的UNIX工具软件、应用程序和网络协议。它支持32位和64位硬件。Linux继承了Unix以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统。
Linux操作系统诞生于1991 年10 月5 日（这是第一次正式向外公布时间）。Linux存在着许多不同的Linux版本，但它们都使用了Linux内核。Linux可安装在各种计算机硬件设备中，比如手机、平板电脑、路由器、视频游戏控制台、台式计算机、大型机和超级计算机。
严格来讲，Linux这个词本身只表示Linux内核，但实际上人们已经习惯了用Linux来形容整个基于Linux内核，并且使用GNU 工程各种工具和数据库的操作系统。