inotify\u添加\u监视在/sys/class/net/eth0/operstate上失败

我在Linux中使用了inotify，以便在网络接口链接更改时引发事件。只要接口链接发生更改，/sys/class/net/eth40/operstate/file就会被修改。但在下面的代码段中，即使文件被修改，read函数仍然处于阻塞状态

#包括
#包括
#包括
#包括
#包括
#定义要监视的文件“/sys/class/net/eth40/operstate”
#定义事件大小（sizeof（结构索引事件））
#定义事件缓冲区长度（1024*事件大小+名称最大值+1）
作废打印事件（结构索引事件*事件）{
int-ret=0；
如果（事件->掩码和创建中）
printf（“在目录中创建的文件”）；
如果（事件->屏蔽和删除中）
printf（“在目录中删除的文件”）；
if（事件->掩码和IN_访问）
printf（“已访问文件”）；
如果（事件->屏蔽和关闭）
printf（“读取或写入后关闭的文件”）；
如果（事件->屏蔽和打开）
printf（“文件已打开”）；
如果（事件->镜头）
printf（“名称：%s\n”，事件->名称）；
}
int main（int argc，字符**argv）
{
int notify_fd；
int watch_fd；
长输入长度；
char*ptr；
字符缓冲区[事件缓冲区长度]；
结构inotify_事件*事件；
notify_fd=inotify_init（）；
如果（通知_fd<0）{
perror（“无法初始化inotify”）；
退出（退出失败）；
}
printf（“done1\n”）；
watch_fd=inotify_add_watch（通知_fd，文件_TO_watch，IN_访问| IN_修改）；
如果（观察fd<0）{
perror（“无法添加文件”）；
退出（退出失败）；
}
printf（“done2\n”）；
而(1){
输入长度=读取（通知fd、缓冲区、事件缓冲区长度）；
如果（输入_len；
}
}
}

/sys不是一个常规文件系统，而是一个名为

引用一句话：

inotify不会也不会在sysfs.或procfs.或devpts上工作。 或任何数量的网络文件系统。无论某人有多努力 我可能希望它能起作用，但这根本不可行

对于网络链接事件，您可以使用rt，尽管像这样的东西很少有文档记录，但这里有一个起点示例，它将向您展示链接（和其他一些）事件，您必须找出与您的特定情况相关的事件/标志和类似物

#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <asm/types.h>
#include <asm/types.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <linux/if.h>
#include <linux/rtnetlink.h>

#define ENTRY(x) {x, #x}
struct {
    unsigned flag;
    const char *name;
} ifi_flag_map[] = {
    ENTRY(IFF_UP),
    ENTRY(IFF_BROADCAST),
    ENTRY(IFF_DEBUG),
    ENTRY(IFF_LOOPBACK),
    ENTRY(IFF_POINTOPOINT),
    ENTRY(IFF_NOTRAILERS),
    ENTRY(IFF_RUNNING),
    ENTRY(IFF_NOARP),
    ENTRY(IFF_PROMISC),
    ENTRY(IFF_ALLMULTI),
    ENTRY(IFF_MASTER),
    ENTRY(IFF_SLAVE),
    ENTRY(IFF_MULTICAST),
    ENTRY(IFF_PORTSEL),
    ENTRY(IFF_AUTOMEDIA),
    ENTRY(IFF_DYNAMIC),
    ENTRY(IFF_LOWER_UP),
    ENTRY(IFF_DORMANT),
    ENTRY(IFF_ECHO),
};
struct {
    unsigned type;
    const char *name;
} nlmrt_type_map[] = {
    ENTRY(RTM_NEWLINK ),
    ENTRY(RTM_DELLINK),
    ENTRY(RTM_GETLINK),
    ENTRY(RTM_SETLINK),
    ENTRY(RTM_NEWADDR ),
    ENTRY(RTM_DELADDR),
    ENTRY(RTM_GETADDR),
    ENTRY(RTM_NEWROUTE    ),
    ENTRY(RTM_DELROUTE),
    ENTRY(RTM_GETROUTE),
    ENTRY(RTM_NEWNEIGH    ),
    ENTRY(RTM_DELNEIGH),
    ENTRY(RTM_GETNEIGH),
    ENTRY(RTM_NEWRULE ),
    ENTRY(RTM_DELRULE),
    ENTRY(RTM_GETRULE),
    ENTRY(RTM_NEWQDISC    ),
    ENTRY(RTM_DELQDISC),
    ENTRY(RTM_GETQDISC),
    ENTRY(RTM_NEWTCLASS   ),
    ENTRY(RTM_DELTCLASS),
    ENTRY(RTM_GETTCLASS),
    ENTRY(RTM_NEWTFILTER  ),
    ENTRY(RTM_DELTFILTER),
    ENTRY(RTM_NEWACTION   ),
    ENTRY(RTM_DELACTION),
    ENTRY(RTM_GETACTION),
    ENTRY(RTM_NEWPREFIX   ),
    ENTRY(RTM_GETMULTICAST ),
    ENTRY(RTM_GETANYCAST  ),
    ENTRY(RTM_NEWNEIGHTBL ),
    ENTRY(RTM_GETNEIGHTBL ),
    ENTRY(RTM_SETNEIGHTBL),
    ENTRY(RTM_NEWNDUSEROPT ),
    ENTRY(RTM_NEWADDRLABEL ),
    ENTRY(RTM_DELADDRLABEL),
    ENTRY(RTM_GETADDRLABEL),
    ENTRY(RTM_GETDCB ),
    ENTRY(RTM_SETDCB),
    ENTRY(RTM_NEWNETCONF ),
    ENTRY(RTM_GETNETCONF ),
    ENTRY(RTM_NEWMDB ),
    ENTRY(RTM_DELMDB ),
    ENTRY(RTM_GETMDB ),
};

void print_type(unsigned type)
{
    size_t i;

    for (i = 0; i < sizeof nlmrt_type_map/sizeof nlmrt_type_map[0]; i++) {
        if (type == nlmrt_type_map[i].type) {
            printf("\t\tMsg Type: %s\n", nlmrt_type_map[i].name);
            return;
        }
    }

    printf("\t\tMsg Type: unknown(%d)\n", type);
}
void print_flags(unsigned flags, unsigned change)
{
    size_t i;

    printf("\t\tflags: ");

    for (i = 0; i < sizeof ifi_flag_map/sizeof ifi_flag_map[0]; i++) {
        if (flags & ifi_flag_map[i].flag) {
            if (change & ifi_flag_map[i].flag) {
                printf("%s(C) ", ifi_flag_map[i].name);
            } else {
                printf("%s ", ifi_flag_map[i].name);
            }
        }
    }
    puts("");
}
oid read_msg(int fd)
{
    int len;
    char buf[4096];
    struct iovec iov = { buf, sizeof(buf) };
    struct sockaddr_nl sa;
    struct msghdr msg = { (void *)&sa, sizeof(sa), &iov, 1, NULL, 0, 0 };
    struct nlmsghdr *nh;

    len = recvmsg(fd, &msg, 0);
    if(len == -1) {
        perror("recvmsg");
        return;
    }

    for (nh = (struct nlmsghdr *) buf; NLMSG_OK (nh, len);
         nh = NLMSG_NEXT (nh, len)) {
         struct ifinfomsg *ifimsg;
        /* The end of multipart message. */
         printf("netlink message: len = %u, type = %u, flags = 0x%X, seq = %u, pid = %u\n",
            nh->nlmsg_len,
            nh->nlmsg_type,
            nh->nlmsg_flags,
            nh->nlmsg_seq,
            nh->nlmsg_pid);

        if (nh->nlmsg_type == NLMSG_DONE)
            return;

       if (nh->nlmsg_type == NLMSG_ERROR) {
            continue;
       }

       ifimsg = NLMSG_DATA(nh);
       printf("\tifi_family = %u, ifi_type = %u, ifi_index = %u, ifi_flags = 0x%X, ifi_change = 0x%X\n",
               ifimsg->ifi_family ,
               ifimsg->ifi_type ,
               ifimsg->ifi_index ,
               ifimsg->ifi_flags ,
               ifimsg->ifi_change);
       print_type(nh->nlmsg_type);
       print_flags(ifimsg->ifi_flags, ifimsg->ifi_change);
    }
}
int main(int argc, char *argv[])
{
    struct sockaddr_nl sa;
    int fd;

    memset(&sa, 0, sizeof(sa));
    sa.nl_family = AF_NETLINK;
    sa.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR;

    fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
    if(fd == -1) {
        perror("socket");
        return 1;
    }

    if(bind(fd, (struct sockaddr *) &sa, sizeof(sa)) == -1) {
        perror("bind");
        return 1;
    }
    for(;;) {
        read_msg(fd);
    }

    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义条目（x）{x，#x}
结构{
未签名的旗帜；
常量字符*名称；
}ifi_标志_地图[]={
进入（IFF_UP），
进入（IFF_广播），
条目（IFF_调试），
条目（IFF_环回），
入口（IFF_PointPoint），
入口（IFF_NOTRAILERS），
输入（IFF_运行），
进入（IFF_NOARP），
进入（IFF_混杂），
条目（IFF_ALLMULTI），
进入（IFF_MASTER），
入口（IFF_从属），
条目（IFF_多播），
入口（IFF_PORTSEL），
条目（IFF_AUTOMEDIA），
输入（IFF_动态），
进入（IFF\U下降\U上升），
进入（IFF_休眠），
输入（IFF_ECHO），
};
结构{
无符号类型；
常量字符*名称；
}nlmrt_类型_地图[]={
条目（RTM_NEWLINK），
入口（RTM_DELLINK），
条目（RTM_GETLINK），
输入（RTM_设置链接），
条目（RTM_NEWADDR），
入口（RTM_DELADDR），
条目（RTM_GETADDR），
入口（RTM_NEWROUTE），
入口（RTM_DELROUTE），
入口（RTM_GETROUTE），
入口（RTM_NEWNEIGH），
入口（RTM_DELNEIGH），
入口（RTM_GETNEIGH），
条目（RTM_新规则），
条目（RTM_DELRULE），
条目（RTM_GETRULE），
条目（RTM_NEWQDISC），
入口（RTM_DELQDISC），
条目（RTM_GETQDISC），
条目（RTM_类），
入口（RTM_DELTCLASS），
进入（RTM_课程），
条目（RTM_过滤器），
入口（RTM_DELTFILTER），
条目（RTM_NEWACTION），
入口（RTM_DELACTION），
输入（RTM_GETACTION），
条目（RTM_NEWPREFIX），
条目（RTM_GETMULTICAST），
入口（RTM_GETANYCAST），
入口（RTM_NEWNEIGHTBL），
入口（RTM_GETNEIGHTBL），
入口（RTM_SETNEIGHTBL），
入口（RTM_Newnduservpt），
条目（RTM_NEWADDRLABEL），
条目（RTM_DELADDRLABEL），
条目（RTM_GETADDRLABEL），
条目（RTM_GETDCB），
输入（RTM_设置DCB），
条目（RTM_NEWNETCONF），
条目（RTM_GETNETCONF），
条目（RTM_NEWMDB），
入口（RTM_DELMDB），
条目（RTM_GETMDB），
};
无效打印类型（无符号类型）
{
尺寸i；
对于（i=0；inlmsg_len，
nh->nlmsg_类型，
nh->nlmsg_标志，
nh->nlmsg_seq，
nh->nlmsg_pid）；
如果（nh->nlmsg\U类型==nlmsg\U完成）
返回；
如果（nh->nlmsg\U类型==nlmsg\U错误）{
继续；
}
ifimsg=NLMSG_数据（nh）；
printf（“\tifi\u系列=%u，ifi\u类型=%u，ifi\u索引=%u，ifi\u标志=0x%X，ifi\u更改=0x%X\n”，