lkml.org 
[lkml]   [2015]   [Apr]   [15]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    From
    Subject[RFC 0/4] Generic file system events interface
    Date

    Hi All,

    The following patchset is a result of previous discussions regarding
    file system threshold notifiactions. It introduces support for file
    system event notifications, sent through generic netlinik interface
    whenever an fs-related event occurs. Included are also some shmem
    and ext4 changes showing how the new interface might actually be used.

    The vary idea of using the generic netlink interface has been previoulsy
    suggested here: https://lkml.org/lkml/2011/8/18/169

    The basic description of the new functionality can be found in
    the first patch from this set - both in the commit message and
    in the doc file.

    Some very basic tests have been performed though still this is
    a PoC version. Below though is a sample user space application
    which subscribes to the new multicast group and listens for
    potential fs-related events. The code has been based on libnl 3.4
    and its test application for the generic netlink.

    ---

    Beata Michalska (4):
    fs: Add generic file system event notifications
    ext4: Add helper function to mark group as corrupted
    ext4: Add support for generic FS events
    shmem: Add support for generic FS events

    Documentation/filesystems/events.txt | 254 +++++++++++
    fs/Makefile | 1 +
    fs/events/Makefile | 6 +
    fs/events/fs_event.c | 775 ++++++++++++++++++++++++++++++++++
    fs/events/fs_event.h | 27 ++
    fs/events/fs_event_netlink.c | 94 +++++
    fs/ext4/balloc.c | 26 +-
    fs/ext4/ext4.h | 10 +
    fs/ext4/ialloc.c | 5 +-
    fs/ext4/inode.c | 2 +-
    fs/ext4/mballoc.c | 17 +-
    fs/ext4/resize.c | 1 +
    fs/ext4/super.c | 43 ++
    fs/namespace.c | 1 +
    include/linux/fs.h | 6 +-
    include/linux/fs_event.h | 69 +++
    include/uapi/linux/fs_event.h | 62 +++
    include/uapi/linux/genetlink.h | 1 +
    mm/shmem.c | 39 +-
    net/netlink/genetlink.c | 7 +-
    20 files changed, 1412 insertions(+), 34 deletions(-)
    create mode 100644 Documentation/filesystems/events.txt
    create mode 100644 fs/events/Makefile
    create mode 100644 fs/events/fs_event.c
    create mode 100644 fs/events/fs_event.h
    create mode 100644 fs/events/fs_event_netlink.c
    create mode 100644 include/linux/fs_event.h
    create mode 100644 include/uapi/linux/fs_event.h

    ---
    Sample application:

    #include <netlink/cli/utils.h>
    #include <fs_event.h>

    #define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
    #define LOG(args...) fprintf(stderr, args)

    static int parse_info(struct nl_cache_ops *unused, struct genl_cmd *cmd,
    struct genl_info *info, void *arg)
    {
    LOG("New trace %d:\n",
    info->attrs[FS_EVENT_ATR_FS_ID]
    ? nla_get_u32(info->attrs[FS_EVENT_ATR_FS_ID])
    : -1);
    LOG("Mout point: %s\n", info->attrs[FS_EVENT_ATR_MOUNT]
    ? nla_get_string(info->attrs[FS_EVENT_ATR_MOUNT])
    : "unknown");
    return 0;
    }

    static int parse_thres(struct nl_cache_ops *unused, struct genl_cmd *cmd,
    struct genl_info *info, void *arg)
    {

    LOG("Threshold notification received for trace %d:\n",
    info->attrs[FS_EVENT_ATR_FS_ID]
    ? nla_get_u32(info->attrs[FS_EVENT_ATR_FS_ID])
    : -1);

    if (info->attrs[FS_EVENT_ATR_DEV_MAJOR])
    LOG("Backing dev major: %u\n",
    nla_get_u32(info->attrs[FS_EVENT_ATR_DEV_MAJOR]));
    if (info->attrs[FS_EVENT_ATR_DEV_MINOR])
    LOG("Backing dev minor: %u\n",
    nla_get_u32(info->attrs[FS_EVENT_ATR_DEV_MINOR]));
    LOG("Proc: %u\n", info->attrs[FS_EVENT_ATR_CAUSED_ID] ?
    nla_get_u32(info->attrs[FS_EVENT_ATR_CAUSED_ID]) : -1);
    LOG("Threshold data: %llu\n", info->attrs[FS_EVENT_ATR_DATA]
    ? nla_get_u64(info->attrs[FS_EVENT_ATR_DATA])
    : 0);

    return 0;
    }

    static int parse_warning(struct nl_cache_ops *unused, struct genl_cmd *cmd,
    struct genl_info *info, void *arg)
    {

    LOG("Warning recieved for trace %d\n", info->attrs[FS_EVENT_ATR_FS_ID] ?
    nla_get_u32(info->attrs[FS_EVENT_ATR_FS_ID]) : -1);
    if (info->attrs[FS_EVENT_ATR_DEV_MAJOR])
    LOG("Backing dev major: %u\n",
    nla_get_u32(info->attrs[FS_EVENT_ATR_DEV_MAJOR]));
    if (info->attrs[FS_EVENT_ATR_DEV_MINOR])
    LOG("Backing dev minor: %u\n",
    nla_get_u32(info->attrs[FS_EVENT_ATR_DEV_MINOR]));
    LOG("Proc: %u\n", info->attrs[FS_EVENT_ATR_CAUSED_ID] ?
    nla_get_u32(info->attrs[FS_EVENT_ATR_CAUSED_ID]) : -1);
    LOG("Warning: %u\n", info->attrs[FS_EVENT_ATR_ID] ?
    nla_get_u32(info->attrs[FS_EVENT_ATR_ID]) : -1);

    return 0;
    }

    static struct genl_cmd cmd[] = {
    {
    .c_id = FS_EVENT_TYPE_NEW_TRACE,
    .c_name = "info",
    .c_maxattr = 2,
    .c_msg_parser = parse_info,
    }, {
    .c_id = FS_EVENT_TYPE_THRESH,
    .c_name = "thres",
    .c_maxattr = 6,
    .c_msg_parser = parse_thres,
    }, {
    .c_id = FS_EVENT_TYPE_WARN,
    .c_name = "warn",
    .c_maxattr = 5,
    .c_msg_parser = parse_warning,
    },
    };

    static struct genl_ops ops = {
    .o_id = GENL_ID_FS_EVENT,
    .o_name = "FS_EVENT",
    .o_hdrsize = 0,
    .o_cmds = cmd,
    .o_ncmds = ARRAY_SIZE(cmd),
    };


    int events_cb(struct nl_msg *msg, void *arg)
    {
    return genl_handle_msg(msg, arg);
    }

    int main(int argc, char **argv)
    {
    struct nl_sock *sock;
    int ret;

    sock = nl_cli_alloc_socket();
    nl_socket_set_local_port(sock, 0);
    nl_socket_disable_seq_check(sock);

    nl_socket_modify_cb(sock, NL_CB_VALID, NL_CB_CUSTOM, events_cb, NULL);

    nl_cli_connect(sock, NETLINK_GENERIC);

    if ((ret = nl_socket_add_membership(sock, GENL_ID_FS_EVENT))) {
    LOG("Failed to add membership\n");
    goto leave;
    }

    if((ret = genl_register_family(&ops))) {
    LOG("Failed to register protocol family\n");
    goto leave;
    }

    if ((ret = genl_ops_resolve(sock, &ops) < 0)) {
    LOG("Unable to resolve the family name\n");
    goto leave;
    }

    if (genl_ctrl_resolve(sock, "FS_EVENT") < 0) {
    LOG("Failed to resolve the family name\n");
    goto leave;
    }

    while (1) {
    if ((ret = nl_recvmsgs_default(sock)) < 0)
    LOG("Unable to receive message: %s\n", nl_geterror(ret));
    }

    leave:
    nl_close(sock);
    nl_socket_free(sock);
    return 0;
    }

    --
    1.7.9.5



    \
     
     \ /
      Last update: 2015-04-15 10:01    [W:4.067 / U:1.000 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site