虚拟设备文件

更新时间:
2024-05-13
下载文档

虚拟设备文件

Linux 内核自 2.6.22 版本开始逐步增加了三个虚拟设备文件:eventfd、timerfd、signalfd。这三个文件让应用程序可以通过标准 I/O 操作的方式代替传统调用 API 的方式来使用事件(信号量)、定时器和信号资源,这带来的最大好处是应用程序可以通过使用 select(或 poll、epoll)同时监听多个此类文件(或此类文件与其他文件),将对多个事件的异步并行处理方便地转化为同步串行处理,这在许多应用中非常有用。SylixOS 完全兼容这三个虚拟设备文件,并且增加了一个 hstimerfd,用于高精度定时器。

下面将分别介绍它们的使用方法。

eventfd

eventfd 主要用于线程之间的事件通知,Linux 由于支持 fork 系统调用,因此也可以用于父子进程之间的事件通知。相关 API 介绍如下:

int eventfd(unsigned int initval, int flags);
int eventfd_read(int fd, eventfd_t *value);
int eventfd_write(int fd, eventfd_t value);

函数 eventfd 原型分析:

  • 该函数成功返回一个文件描述符,失败返回负数并设置错误号。
  • 参数 initval 表示事件的初始状态,例如为 0 表示当前没有任何事件产生。
  • 参数 flags 为该事件文件的操作选项,可以为 EFD_CLOEXEC、EFD_NONBLOCK、和 EFD_SEMAPHORE。EFD_SEMAPHORE 的具体含义随后讲解。

函数 eventfd_read 用于读取事件文件,即等待事件的发送。当没有事件且未使用 EFD_NONBLOCK 参数,该函数将会阻塞,其原型分析如下:

  • 该函数成功返回 0,失败返回错误码。
  • 参数 fd 即为通过 eventfd 打开的一个事件文件描述符。
  • 输出参数 value 保存读取的事件数量值,其行为与 EFD_SEMAPORE 标志有关。eventfd_t 在大多数系统中被定义为一个无符号 64 位整型数,正常情况下,它能表示的事件数量可以理解为无限多。

当使用 eventfd 函数的参数 flags 包含了 EFD_SEMAPHORE 时,其含义为将事件按照计数信号量来操作。即如果当前已经产生了多个事件,每一次读取只会获得一个事件,该文件内部的事件计数器只减一, value 里面的内容为 1。当没有使用 EFD_SEMAPHORE 时,一次读取所有的事件,value 里面的内容即为读取的事件数量,内部的事件计数器归零。两种方式可满足应用程序在不同场景的需求。

函数 eventfd_write 用于写事件文件,即发送事件。当内部事件计数器达到最大值时,将不能继续发送事件,此时返回错误,其原型分析如下:

  • 该函数成功返回 0,失败返回错误码。
  • 参数 fd 即为通过 eventfd 打开的一个事件文件描述符。
  • 输入参数 value 为发送的事件数量,其行为与 EFD_SEMAPHORE 标志有关。

下面的例子展示了 eventfd 的使用方法。

#include <stdio.h>
#include <sys/eventfd.h>
#include <pthread.h>
void *event_write_routine (void *arg)
{
    eventfd_t      value      = 1;
    int            event_fd   = (int)arg;
    int            ret;
    while (1) {
        ret = eventfd_write(event_fd, value);
        if (ret) {
            fprintf(stderr, "write eventfd error.\n");
            break;
        }
        value++;
    }
    return  (NULL);
}
int event_write_server_start (int event_fd, void  *(*routine)(void *))
{
    pthread_t    tid;
    int          ret;
    ret = pthread_create(&tid, NULL, routine, (void *)event_fd);
    if (ret != 0) {
        fprintf(stderr, "pthread create failed.\n");
        return  (-1);
    }
    return  (0);
}
int main (int argc, char *arvg[])
{
    int            event_fd;
    int            ret;
    eventfd_t      value;
    event_fd = eventfd(0, 0);
    if (event_fd < 0) {
        fprintf(stderr, "open eventfd failed.\n");
        return  (-1);
    }
    ret = event_write_server_start(event_fd, event_write_routine);
    if (ret) {
        fprintf(stderr, "start eventfd write server failed.\n");
        close(event_fd);
        return  (-1);
    }
    while (1) {
        ret = eventfd_read(event_fd, &value);
        if (ret) {
            fprintf(stderr, "read eventfd error.\n");
            break;
        }
        fprintf(stdout, "read event value count: %llu.\n", value);
    }
    close(event_fd);
    return  (0);
}

在上面的程序中,子线程不断地往事件文件写入数值递增的事件,主线程不断地读取事件并打印本次事件的数值。其运行结果如下:

# ./event_Synchronization_between_threads
read event value count: 1.
read event value count: 2.
read event value count: 3.
read event value count: 4.
read event value count: 5.
read event value count: 6.
read event value count: 7.
read event value count: 8.

上面的结果非常规律,可以看出,每一次读取的事件数值反映的仅仅是一次写入的事件数值,而不会是多次写入数值的总和。实际上,eventfd_write 函数总是会等待上一次写入的事件被读取后才能完成本次事件的写入,所以,事件文件的读和写是一个相互同步的过程,一次事件的数值可理解为事件发生后所能处理的资源数量,EFD_SEMAPHORE 则允许事件接收方决定是一次处理多个资源还是单个资源。

timerfd

在“时间管理”章节,我们曾介绍了使用 SylixOS 定时器相关的 API 函数,使用 timerfd 也同样能够实现定时器功能,相关 API 如下。

#include <timerfd.h>
int timerfd_create(clockid_t clockid, int flags);
int timerfd_settime(int fd, int flags, const struct itimerspec *ntmr, 
struct itimerspec *otmr);
int timerfd_gettime(int fd, struct itimerspec *currvalue);

函数 timerfd_create 原型分析:

  • 该函数成功返回定时器文件描述符,失败返回负数并设置错误号。
  • 参数 clockid 表示该定时器参考的时钟源类型,可以为 CLOCK_REALTIME 或 CLOCK_MONOTONIC,分别代表真实时间和线性递增时间。
  • 参数 flags 是定时器文件选项位标识,可以是 TFD_CLOEXEC(等于 O_CLOEXEC)和 TFD_NONBLOCK(等于 O_NONBLOCK)。

函数 timerfd_settime 用于设置定时器启动时间以及重载时间间隔。原型分析如下:

  • 该函数成功返回 0,失败返回负数并设置错误号。
  • 参数 fd 为定时器文件描述符。
  • 参数 flags 为与定时时间相关的标识,可以是 0 或者 TIMER_ABSTIME,它影响参数 ntmr 的含义。
  • 参数 ntmr 描述了定时器的时间参数:启动时间和重载时间。
  • 输出参数 otmr 保存旧的时间参数。可以为 NULL。

数据类型 itimerspec 定义如下:

struct itimerspec {
    struct timespec  it_interval;                      /*  定时器重载值                 */
    struct timespec  it_value;                         /*  到下一次到期为止剩余时间      */
};

it_interval 为定时器周期触发的时间间隔,it_value 表示定时器第一次触发的时间。该值的含义由 flags 定义,如果设置了 TIMER_ABSTIME 标识,则表示 it_value 为一个绝对时间,当系统时间到达该值时定时器触发。如果 flags 为 0,则表示 it_value 为一个相对时间,经过该时间值后定时器触发。两者的类型都为 timespec,这意味着,定时器可以达到纳秒级别的时间精度。

函数 timerfd_gettime 获得定时器文件当前的时间参数,其原型分析如下:

  • 该函数成功返回 0,失败返回负数并设置错误号。
  • 参数 fd 为定时器文件描述符。
  • 输出参数 currvalue 保存当前时间参数。

一旦调用 timerfd_settime 成功,即会启动定时器,并在满足设置的时间条件时触发定时器。应用程序可使用 read 或 select 来等待定时器触发(与 GPIO 设备相同)。

程序清单 timerfd应用示例(Application_of_Timerfd)

#include <sys/timerfd.h>
#include <stdio.h>
#include <stdint.h>
#include <time.h>
static int  show_elapsed_time (void)
{
    static struct timespec     start;
    struct timespec            curr;
    static int                 first_call = 1;
    int                        secs;
    int                        nsecs;
    if (first_call) {
        first_call = 0;
        if (clock_gettime(CLOCK_MONOTONIC, &start) == -1) {
            return   (-1);
        }
    }
    if (clock_gettime(CLOCK_MONOTONIC, &curr) == -1) {
        return  (-1);
    }
    secs      = curr.tv_sec - start.tv_sec;
    nsecs = curr.tv_nsec - start.tv_nsec;
    if (nsecs < 0) {
        secs--;
        nsecs += 1000000000;
    }
fprintf(stdout, "time elapsed: %d.%03d seconds.\n", 
secs, (nsecs + 500000) / 1000000);
    return  (0);
}
int main(int argc, char *argv[])
{
    struct itimerspec     time;
    int                   timer_fd;
    int                   ret;
    uint64_t              expired;
    ssize_t               read_len;
    timer_fd = timerfd_create(CLOCK_MONOTONIC, 0);
    if (timer_fd < 0) {
        fprintf(stderr, "create timerfd failed.\n");
        return  (-1);
    }
    time.it_value.tv_sec        = 3;
    time.it_value.tv_nsec       = 0;
    time.it_interval.tv_sec     = 1;
    time.it_interval.tv_nsec    = 0;
    ret = timerfd_settime(timer_fd, 0, &time, NULL);
    if (ret) {
        fprintf(stderr, "start timerfd error.\n");
        close(timer_fd);
        return  (-1);
    }
    ret = show_elapsed_time();
    if (ret) {
        close(timer_fd);
        return  (-1);
}
    while (1) {
        read_len = read(timer_fd, &expired, sizeof(uint64_t));
        if (read_len < sizeof(uint64_t)) {
            fprintf(stderr, "read timerfd error.\n");
            break;
        }
        ret = show_elapsed_time();
        if (ret) {
            break;
        }
        fprintf(stdout, "timer is triggered, expire count = %llu.\n", expired);
        sleep(2);
    }
    close(timer_fd);
    return  (0);
}

上面的程序中,创建定时器时,其参数 flags 为 0,表示使用相对时间,在调用 timerfd_settime 时,其时间参数的设置表示,定时器自启动后经过 3 秒触发,之后每隔 1 秒触发一次。私有函数 show_elapsed_time 用于显示自定时器启动后所经过的时间,以此作为检验定时器精确度的一个标准。程序在等待定时器第一次触发后,每隔 2 秒周期性地去等待定时器的触发状态。

注意,这里通过 read 的方式等待定时器触发,其读取的数据为一个 64 位无符号类型,该数据表示的是定时器到本次触发为止总共触发了多少次,我们也把它叫做定时器到期的次数。

程序运行后,结果如下:

# ./Application_of_Timerfd
time elapsed: 0.000 seconds.
time elapsed: 2.996 seconds.
timer is triggered, expire count = 1.
time elapsed: 4.996 seconds.
timer is triggered, expire count = 2.
time elapsed: 6.996 seconds.
timer is triggered, expire count = 2.
time elapsed: 8.996 seconds.
timer is triggered, expire count = 2.
time elapsed: 10.996 seconds.
timer is triggered, expire count = 2.
time elapsed: 12.996 seconds.
timer is triggered, expire count = 2.
......

从结果可以看出,定时器在第一次触发时,经过了 2.996 秒(有一定精度偏差),并且显示定时器到期计数为 1,这符合我们的设定。在之后,由于定时器每隔 1 秒触发一次,因此我们每隔 2 秒去获得的定时器到期计数为 2,也与预期一致。

需要注意的是,设定定时器时间参数时,如果 it_value 的时间值为 0,并不表示定时器立即触发,而是表示停止定时器。同样的,it_interval 的时间值为 0,也不表示定时器无等待时间无限触发,而是停止定时器。

hstimerfd

SylixOS 支持时间精度可高于系统时钟的定时器,并提供相关 API 函数(见“时间管理”章节),高精度定时器只能保证其时间精度不低于普通定时器,这完全取决于系统硬件以及 BSP 包的支持。SylixOS 同样提供了类似于 timrfd 的 hstimerfd 文件,让应用程序通过标准 I/O 使用高精度定时器。相关 API 定义如下:

#include <sys/hstimerfd.h>
int hstimerfd_hz(void);
int hstimerfd_create(int flags);
int hstimerfd_settime(int fd, 
                      const struct itimerspec    *ntmr, 
                      struct itimerspec          *otmr);
int hstimerfd_settime2(int fd, hstimer_cnt_t *ncnt, hstimer_cnt_t *ocnt);
int hstimerfd_gettime(int fd, struct itimerspec *currvalue);
int hstimerfd_gettime2(int fd, hstimer_cnt_t *currvalue);

hstimerfd_settime 与 hstimerfd_gettime 与上一节的普通定时器 API 的参数和行为一致。hstimerfd_hz 函数返回高精度定时器的计数频率,亦是可以达到的定时精度。

函数 hstimerfd_create 原型分析:

  • 该函数成功时返回文件描述符,失败时返回负数并设置错误号。
  • 参数 flags 为文件标识,可以是 HSTFD_CLOEXEC(等于 O_CLOEXEC)和 HSTFD_NONBLOCK(等于 O_NONBLOCK)。

函数 hstimerfd_settime2 原型分析:

  • 该函数成功返回 0,失败返回错误码。
  • 参数 fd 为高精度定时器文件描述符。
  • 参数 ncnt 类似为 hstimer_cnt_t,表示新的定时器时间计数参数。
  • 输出参数 ocnt 保存旧的定时器时间计数参数。

hstimerfd 提供了新的时间参数方式,即使用高精度定时器的计数值来作为其时间参数,数据结构 hstimer_cnt_t 定义如下:

typedef struct hstimer_cnt {
    unsigned long   value;
    unsigned long   interval;
} hstimer_cnt_t;

成员变量 value 表示定时器自启动后第一次触发经过的计数值(即首次到期计数值),interval 为定时器周期触发的计数值。

函数 hstimerfd_gettime2 原型分析:

  • 该函数成功返回 0,失败返回错误码。
  • 参数 fd 为高精度定时器文件描述符。
  • 输出参数 currvalue 保存定时器当前的时间参数。

高精度定时器除了时间精度与普通定时器有区别以外,其他行为与普通定时器相似,因此这里不再给出相关示例。读者可根据程序清单 程序清单 timerfd应用示例(Application_of_Timerfd)的程序稍作修改,即可使用高精度定时器。

signalfd

传统的信号处理方式是使用 signal 或 sigaction 函数注册关心的信号处理函数,在信号发生时,这些函数会以异步的方式被调用,因此在使用中需要考虑数据并发的问题,其相关 API 及其使用方法见“信号系统”章节。signalfd 允许应用程序以文件的方式等待信号的产生并同步处理这些信号,signalfd 为一个标准 I/O 设备文件,其定义位于 <sys/signalfd.h> 头文件,如下所示:

#include <sys/signalfd.h>
int signalfd(int fd, const sigset_t *mask, int flags);

函数 signalfd 原型分析:

  • 该函数成功返回一个信号文件描述符,失败返回负数并设置错误号。
  • 参数 fd 表示一个已有的信号文件描述符。如果为-1 则表示新创建一个信号文件;如果 fd 为一个已有的信号文件描述符,则表示重新设置其需要处理的信号。
  • 参数 mask 为一个包含了需要关心的信号集。
  • 参数 flags 可以为 SFD_CLOEXEC(等于 O_CLOEXEC)和 SFD_NONBLOCK(等于 O_NONBLOCK)。

当成功调用 signalfd 函数后,其返回的文件描述符即与参数 mask 所指定的信号进行了关联。之后使用 read 函数等待信号的发生,读取的数据为一个 signalfd_siginfo 结构,其定义如下:

struct signalfd_siginfo {
    uint32_t     ssi_signo;            /* Signal number                          */
    int32_t      ssi_errno;            /* Error number (unused)                  */
    int32_t      ssi_code;             /* Signal code                            */
    uint32_t     ssi_pid;              /* PID of sender                          */
    uint32_t     ssi_uid;              /* Real UID of sender                     */
    int32_t      ssi_fd;               /* File descriptor (SIGIO)                */
    uint32_t     ssi_tid;              /* Kernel timer ID (POSIX timers)         */
    uint32_t     ssi_band;             /* Band event (SIGIO)                     */
    uint32_t     ssi_overrun;          /* POSIX timer overrun count              */
    uint32_t     ssi_trapno;           /* Trap number that caused signal         */
    int32_t      ssi_status;           /* Exit status or signal (SIGCHLD)        */
    int32_t      ssi_int;              /* Integer sent by sigqueue(3)            */
    uint64_t     ssi_ptr;              /* Pointer sent by sigqueue(3)            */
    uint64_t     ssi_utime;            /* User CPU time consumed (SIGCHLD)       */
    uint64_t     ssi_stime;            /* System CPU time consumed (SIGCHLD)     */
    uint64_t     ssi_addr;             /* Address that generated signal          */
                                       /* (for hardware-generated signals)       */
    uint8_t      pad[48];
};

signalfd_siginfo 的成员变量 ssi_signo 为当前信号的编号,我们可以根据它对不同的信号作对应的处理。signalfd_siginfo 与 siginfo_t 的很多同名成员的含义相同,关于 siginfo_t 的详细介绍见“信号系统”章节。

下面以一个简单的例子展示 signalfd 的使用方法。

#include <sys/signalfd.h>
#include <stdio.h>
#include <stdint.h>
#include <signal.h>
#include <stdlib.h>
int main (int argc, char *argv[])
{
    sigset_t                        sig_mask;
    int                             sig_fd;
    struct signalfd_siginfo         sig_info;
    ssize_t                         read_size;
    sigemptyset(&sig_mask);
    sigaddset(&sig_mask, SIGINT);
    sigaddset(&sig_mask, SIGQUIT);
    if (sigprocmask(SIG_BLOCK, &sig_mask, NULL) == -1) {
        fprintf(stderr,"sigprocmask error.\n");
        return  (-1);
    }
    sig_fd = signalfd(-1, &sig_mask, 0);
    if (sig_fd < 0) {
        fprintf(stderr, "crteate signalfd error.\n");
        return  (-1);
    }
    while (1) {
        read_size = read(sig_fd, &sig_info, sizeof(struct signalfd_siginfo));
        if (read_size != sizeof(struct signalfd_siginfo)) {
           fprintf(stderr, "read signalfd error.\n");
           break;
        }
        if (sig_info.ssi_signo == SIGINT) {
           printf("got SIGINT signal.\n");
        } else if (sig_info.ssi_signo == SIGQUIT) {
           printf("got SIGQUIT signal.\n");
           break;
        } else {
           fprintf(stderr, "got unexpected signal.\n");
        }
    }
    close(sig_fd);
    return  (0);
}

上面的程序中,我们将关心的两个信号 SIGINT 和 SIGQUIT 加入信号集中,随后通过 sigprocmask 将这两个信号阻塞。这里和使用 signal 或 sigaction 处理信号的方式不同,它们要求关心的信号不能被阻塞,而使用 signalfd 时,如果不阻塞这些信号,则当信号发生时会转到默认的信号处理函数中。

当信号发生时,虽然这些信号被阻塞了,但系统会将与这些信号关联的文件置为可读状态,因此我们使用 read 函数等待信号的发生。使用这种方式,SIGINT 和 SIGQUIT 在一个线程里被串行处理。该程序在运行后,首先通过 ps 命令查看其结果如下:

# ./Application_of_Signalfd &
# ps
      NAME                  FATHER      STAT  PID   GRP    MEMORY    UID   GID   USER
----------------------- --------------- ---- ----- ----- ---------- ----- ----- ------
kernel                     <orphan>       R     0     0       16KB      0     0  root
Application_of_Signalfd    <orphan>       R   124   124      232KB      0     0  root

测试程序的名称为 sigfd_test,其 PID 为 124(PID 的值根据实际情况会发生变化),下面我们使用 kill 命令向该进程发送关心的两个信号,SIGINT 对应的编号为 2,SIGQUIT 对应的编号为 3,结果如下:

# kill -n 2 124
got SIGINT signal.
# kill -n 2 124
got SIGINT signal.

在 Linux 下,我们使用 Ctrl+C 组合键即可给当前进程发送 SIGINT 信号,使用 Ctrl+\ 组合键即可对当前进程发送 SIGQUIT 信号。在 SylixOS 中,使用 Ctrl+C 总是使当前进程退出,而不会输出上面的信息。

bmsgfd

bmsgfd设备用于线程间通信功能,由于 bmsgfd 是文件系统中存在的文件,因此也可以用于不同进程之间的通信,通过 bmsgfd 设备在两个进程中实现消息传递,相关 API 定义如下:

#include <sys/bmsgfd.h>
int bmsgfd(const char *name, int flags, ...);

函数 bmsgfd 原型分析:

  • 此函数返回大于0的文件描述符,失败返回-1。
  • 参数 name 是 msg 名字。
  • 参数 flags 是文件打开的标志。
  • 参数 ... 是可变参数列表。
#include <sys/bmsgfd.h>
int bmsgfd_bind(int fd, const char *name);

函数 bmsgfd_bind 原型分析:

  • 此函数返回错误号。
  • 参数 fd 是文件描述符。
  • 参数 name 是 msg 名字。
#include <sys/bmsgfd.h>
int bmsgfd_unbind(int fd);

函数 bmsgfd_unbind 原型分析:

  • 此函数返回错误号。
  • 参数 fd 是文件描述符。
#include <sys/bmsgfd.h>
int bmsgfd_timeout(int fd, unsigned long *send_ms, unsigned long *recv_ms);

函数 bmsgfd_timeout 原型分析:

  • 此函数返回错误号。
  • 参数 fd 是文件描述符。
  • 参数 send_ms 是发送超时时间。
  • 参数 recv_ms 是接收超时时间。

bmsgfd 函数用于打开一个 bmsg 文件,如果指定的 flags 值包含 O_CREAT 和 BMSGFD_SETBUFFER,则需要指定第三个参数的模式值(该值为8进制类型值,例如0666)和第四个参数 struct bmsg_param。

struct bmsg_param 结构体定义

struct bmsg_param {
    UINT32   param_flags;                                 /*  FIOBMSGSET set options      */
    UINT32   total_size;                                  /*  total buffer size           */
    UINT32   atomic_size;                                 /*  max atomic size in buffer   */
    UINT32   auto_unlink;                                 /*  unlink on last close        */
    UINT32   reserved[4];
};
  • param_flags:FIOBMSGSET 选项,是否强制设置缓冲区参数。
  • total_size:总缓冲区大小。
  • atomic_size:缓冲区中单个消息块的最大占用空间大小。
  • auto_unlink:bmsg 关闭的时候是否自动删除文件。

下面程序展示了两个进程通过 bmsg 来通信的场景。

进程1:打开进程2创建的 bmsg 文件,写满 bmsg 缓冲区并通知进程2。

#include <stdio.h>
#include <string.h>
#include <semaphore.h>
#include <sys/bmsgfd.h>

#define BMSG_NAME       "bmsg1"
#define WRITE_DATA      "abcdefghijklmnopqrstuvwxyz"
#define SEM_FILE        "sem_named"

int main (int argc, char **argv)
{
    int                 fd, ret;
    sem_t              *sem;
    ssize_t             ssret;
    unsigned long       send_timeout = 1000;

    sem = sem_open(SEM_FILE, 0);
    if (sem == SEM_FAILED) {
        perror("sem_open");
        return (-1);
    }

    fd = bmsgfd(BMSG_NAME, O_RDWR);
    if (fd < 0) {
         perror("bmsgfd");
         return (-1);
     }

    ret = bmsgfd_timeout(fd, &send_timeout, NULL);
    if (ret < 0) {
        perror("bmsgfd_timeout");
        return(-1);
    }

    while (1) {
        ssret = write(fd, WRITE_DATA, strlen(WRITE_DATA));
        if (ssret != strlen(WRITE_DATA)) {
            if (ssret < 0) {
                perror("write");
                return (-1);
            }
            break;
        }
    }

    printf("write finish\n");

    sem_post(sem);
    sem_wait(sem);
    sem_close(sem);
    sem_unlink(SEM_FILE);

    return  (0);
}

进程2:创建 bmsg 文件,等待进程1写满 bmsg 缓冲区后开始读取缓冲区消息。

#include <stdio.h>
#include <string.h>
#include <semaphore.h>
#include <sys/bmsgfd.h>

#define BMSG_READ_SIZE  64
#define BMSG_NAME       "bmsg1"
#define WRITE_DATA      "abcdefghijklmnopqrstuvwxyz"
#define SEM_FILE        "sem_named"

int main (int argc, char **argv)
{
    int                 fd, ret;
    char                rbuf[BMSG_READ_SIZE] = {0};
    sem_t              *sem;
    ssize_t             ssret;
    unsigned long       recv_timeout = 1000;
    struct bmsg_param   bp;

    bp.param_flags = 1;
    bp.total_size = 128;
    bp.atomic_size = strlen(WRITE_DATA);
    bp.auto_unlink = 1;

    sem_unlink(SEM_FILE);

    sem = sem_open(SEM_FILE, O_CREAT, 0644, 0);
    if (sem == SEM_FAILED) {
        perror("sem_open");
        return (-1);
    }

    fd = bmsgfd(BMSG_NAME, O_CREAT | BMSGFD_SETBUFFER | O_RDWR, 0666, &bp);
    if (fd < 0) {
        perror("bmsgfd");
        return(-1);
    }

    ret = bmsgfd_timeout(fd, NULL, &recv_timeout);
    if (ret < 0) {
        perror("bmsgfd_timeout");
        return(-1);
    }

    sem_wait(sem);

    while (1) {
        bzero(rbuf, sizeof(rbuf));

        ssret = read(fd, rbuf, sizeof(rbuf));
        if (ssret != strlen(WRITE_DATA)) {
            if (ssret < 0) {
                perror("read");
                return (-1);
            }
            break;
        }

        printf("recv: %s\n", rbuf);
    }

    printf("read finish\n");

    sem_post(sem);
    sem_close(sem);

    return  (0);
}

在 SylixOS shell 下运行程序:

# ./process2 &
# ./process1
write finish
recv: abcdefghijklmnopqrstuvwxyz
recv: abcdefghijklmnopqrstuvwxyz
recv: abcdefghijklmnopqrstuvwxyz
recv: abcdefghijklmnopqrstuvwxyz
read finish

从运行结果看,进程1写满了 bmsg 缓冲区,进程2收到信号后开始读取缓冲区,继而打印:

write finish
recv: abcdefghijklmnopqrstuvwxyz
recv: abcdefghijklmnopqrstuvwxyz
recv: abcdefghijklmnopqrstuvwxyz
recv: abcdefghijklmnopqrstuvwxyz
read finish

semfd

semfd 设备实现了标准信号量的功能,可以用于两个不同线程之间通信,由于 semfd 是文件系统中存在的文件,因此也可以用于不同进程之间的通信,通过 semfd 设备可以在两个进程之间实现信号量的 PEND 和 POST 操作,SylixOS 针对 semfd 设备提供了两个标准接口供应用程序使用。

#include <sys/semfd.h>
int semfd(const char *name, int flags, ...);

函数 semfd 原型分析:

  • 此函数成功返回大于0的文件描述符,失败返回-1。
  • 参数 name 是 semfd 文件名字。
  • 参数 flags 是文件打开的标志。
  • 参数 ... 是可变参数列表。
#include <sys/semfd.h>
int semfd_timeout (int fd, unsigned long *ms);

函数 semfd_timeout 原型分析:

  • 此函数成功返回0,失败返回-1。
  • 参数 fd 是文件描述符。
  • 参数 ms 是信号量超时值。

semfd 函数用于打开一个信号量设备,如果指定的 flags 值包含 O_CREAT,则需要指定第三个参数的模式值(该值为8进制类型值,例如0666)和第四个参数 struct semfd_param。

struct semfd_param 结构体定义

struct semfd_param {
    semfd_type      sem_type;                             /*  Type                        */
    UINT32          sem_opts;                             /*  Options                     */
    UINT32          sem_value;                            /*  Initial value               */
    UINT32          sem_max;                              /*  Max value                   */
    UINT32          auto_unlink;                          /*  unlink on last close        */
    UINT32          reserved[3];
};
  • sem_type:信号量类型包括:
    • SEMFD_TYPE_BINARY(二值信号量)。
    • SEMFD_TYPE_COUNTING(计数信号量)。
    • SEMFD_TYPE_MUTEX(互斥信号量)。
  • sem_opts:信号量选项,与内核信号量选项一致。
  • sem_value:信号量的初始化值,范围 [0, 2147483647]。
  • sem_max:信号量的最大值,范围[0, 2147483647]。
  • auto_unlink:信号量关闭的时候是否自动删除文件。

注意:name 指定的文件将被自动创建到 /dev/semfd 目录下。

semfd_timeout 函数用于设置信号量的超时值,单位为毫秒,特殊地,如果超时时间被指定为 unsigned long 最大值,信号量的超时值将被设置为永远等待。

下面程序展示了两个进程通过 semfd 来操作二值信号量的场景。

进程1:创建二值信号量类型的 semfd。

#include <stdio.h>
#include <sys/semfd.h>

int main (int argc, char **argv)
{
    int     fd;
    int     semval;
    struct semfd_param sfp;
    unsigned long tmo;

    sfp.auto_unlink = 1;
    sfp.sem_max = 1;
    sfp.sem_value = 0;
    sfp.sem_type = SEMFD_TYPE_BINARY;
    sfp.sem_opts = 0;

    fd = semfd("test", O_CREAT | O_RDWR, 0666, &sfp);
    if (fd < 0) {
        perror("semfd");
        return  (-1);
    }

    tmo = ULONG_MAX;

    semfd_timeout(fd, &tmo);

    read(fd, &semval, sizeof(int));
    printf("semfd read value: %d\n", semval);

    close(fd);

    return  (0);
}

进程2:打开进程1创建的 semfd。

#include <stdio.h>
#include <sys/semfd.h>

int main (int argc, char **argv)
{
    int     fd;
    int     semval;

    fd = semfd("test", O_RDWR);
    if (fd < 0) {
        perror("semfd");
        return  (-1);
    }

    semval = 1;

    printf("semfd write value: %d\n", semval);

    write(fd, &semval, sizeof(int));

    return  (0);
}

在 SylixOS shell 下运行程序:

# ./process1 &
# ./process2 
semfd write value: 1
semfd read value: 1

从运行结果看进程1运行之后将等待二进制信号量有效,进程2使信号量有效,继而打印:

semfd write value: 1
semfd read value: 1

结果我们看到写了信号量值1,读到的信号量值也是1,需要注意的是,semfd 并不会传递信号量的值,无论 write 写入的值是多少,read 值将总是1。

文档内容是否对您有所帮助?
有帮助
没帮助