Management

Modules
	Controller

Data Structures
struct	genl_cmd
	Generic Netlink Command. More...
struct	genl_ops
	Generic Netlink Operations. More...

Functions
char *	genl_op2name (int family, int op, char *buf, size_t len)

Register/Unregister
int	genl_register (struct nl_cache_ops *ops)
	Register generic netlink operations.
void	genl_unregister (struct nl_cache_ops *ops)
	Unregister generic netlink operations.

Resolving ID/Name
int	genl_ops_resolve (struct nl_handle *handle, struct genl_ops *ops)
int	genl_mngt_resolve (struct nl_handle *handle)

Detailed Description

1) Registering a generic netlink module

#include <netlink/genl/mngt.h>
 
// First step is to define all the commands being used in
// particular generic netlink family. The ID and name are
// mandatory to be filled out. A callback function and
// most the attribute policy that comes with it must be
// defined for commands expected to be issued towards
// userspace.
static struct genl_cmd foo_cmds[] = {
        {
                .c_id           = FOO_CMD_NEW,
                .c_name         = "NEWFOO" ,
                .c_maxattr      = FOO_ATTR_MAX,
                .c_attr_policy  = foo_policy,
                .c_msg_parser   = foo_msg_parser,
        },
        {
                .c_id           = FOO_CMD_DEL,
                .c_name         = "DELFOO" ,
        },
};
 
// The list of commands must then be integrated into a
// struct genl_ops serving as handle for this particular
// family.
static struct genl_ops my_genl_ops = {
        .o_cmds                 = foo_cmds,
        .o_ncmds                = ARRAY_SIZE(foo_cmds),
};
 
// Using the above struct genl_ops an arbitary number of
// cache handles can be associated to it.
//
// The macro GENL_HDRSIZE() must be used to specify the
// length of the header to automatically take headers on
// generic layers into account.
//
// The macro GENL_FAMILY() is used to represent the generic
// netlink family id.
static struct nl_cache_ops genl_foo_ops = {
        .co_name                = "genl/foo",
        .co_hdrsize             = GENL_HDRSIZE(sizeof(struct my_hdr)),
        .co_msgtypes            = GENL_FAMILY(GENL_ID_GENERATE, "foo"),
        .co_genl                = &my_genl_ops,
        .co_protocol            = NETLINK_GENERIC,
        .co_request_update      = foo_request_update,
        .co_obj_ops             = &genl_foo_ops,
};
 
// Finally each cache handle for a generic netlink family
// must be registered using genl_register().
static void __init foo_init(void)
{
        genl_register(&genl_foo_ops);
}
 
// ... respectively unregsted again.
static void __exit foo_exit(void)
{
        genl_unregister(&genl_foo_ops);
}

Function Documentation

genl_op2name()

char * genl_op2name	(	int	family,
		int	op,
		char *	buf,
		size_t	len
	)

Definition at line 139 of file mngt.c.

{
        struct genl_ops *ops;
        int i;
 
        nl_list_for_each_entry(ops, &genl_ops_list, o_list) {
                if (ops->o_family == family) {
                        for (i = 0; i < ops->o_ncmds; i++) {
                                struct genl_cmd *cmd;
                                cmd = &ops->o_cmds[i];
 
                                if (cmd->c_id == op) {
                                        strncpy(buf, cmd->c_name, len - 1);
                                        return buf;
                                }
                        }
                }
        }
 
        strncpy(buf, "unknown", len - 1);
        return NULL;
}

genl_register()

int genl_register

(

struct nl_cache_ops *

ops

)

Parameters

ops	cache operations

Definition at line 172 of file mngt.c.

{
        int err;
 
        if (ops->co_protocol != NETLINK_GENERIC) {
                err = nl_error(EINVAL, "cache operations not for protocol " \
                               "NETLINK_GENERIC (protocol=%s)",
                               ops->co_protocol);
                goto errout;
        }
 
        if (ops->co_hdrsize < GENL_HDRSIZE(0)) {
                err = nl_error(EINVAL, "co_hdrsize too short, probably " \
                               "not including genlmsghdr, minsize=%d",
                               GENL_HDRSIZE(0));
                goto errout;
        }
 
        if (ops->co_genl == NULL) {
                err = nl_error(EINVAL, "co_genl is NULL, must provide " \
                               "valid genl operations");
                goto errout;
        }
 
        ops->co_genl->o_cache_ops = ops;
        ops->co_genl->o_name = ops->co_msgtypes[0].mt_name;
        ops->co_genl->o_family = ops->co_msgtypes[0].mt_id;
        ops->co_msg_parser = genl_msg_parser;
 
        /* FIXME: check for dup */
 
        nl_list_add_tail(&ops->co_genl->o_list, &genl_ops_list);
 
        err = nl_cache_mngt_register(ops);
errout:
        return err;
}

References nl_cache_ops::co_msg_parser, nl_msgtype::mt_id, nl_msgtype::mt_name, and nl_cache_mngt_register().

genl_unregister()

void genl_unregister

(

struct nl_cache_ops *

ops

)

Parameters

ops	cache operations

Definition at line 214 of file mngt.c.

{
        nl_cache_mngt_unregister(ops);
        nl_list_del(&ops->co_genl->o_list);
}

References nl_cache_mngt_unregister().

genl_ops_resolve()

int genl_ops_resolve	(	struct nl_handle *	handle,
		struct genl_ops *	ops
	)

Definition at line 243 of file mngt.c.

{
        struct nl_cache *ctrl;
        int err;
 
        ctrl = genl_ctrl_alloc_cache(handle);
        if (ctrl == NULL) {
                err = nl_get_errno();
                goto errout;
        }
 
        err = __genl_ops_resolve(ctrl, ops);
 
        nl_cache_free(ctrl);
errout:
        return err;
}

genl_mngt_resolve()

int genl_mngt_resolve

(

struct nl_handle *

handle

)

Definition at line 261 of file mngt.c.

{
        struct nl_cache *ctrl;
        struct genl_ops *ops;
        int err = 0;
 
        ctrl = genl_ctrl_alloc_cache(handle);
        if (ctrl == NULL) {
                err = nl_get_errno();
                goto errout;
        }
 
        nl_list_for_each_entry(ops, &genl_ops_list, o_list) {
                err = __genl_ops_resolve(ctrl, ops);
        }
 
        nl_cache_free(ctrl);
errout:
        return err;
}