int register_ptp_netlink(void) {
int returnValue;
printk(KERN_INFO DRIVER_NAME ": Registering PTP Generic Netlink family\n");
/* Register the Generic Netlink family for use */
returnValue = genl_register_family(&ptp_events_genl_family);
if(returnValue != 0) {
printk(KERN_INFO DRIVER_NAME ": Failed to register Generic Netlink family\n");
goto register_failure;
}
/* Register operations */
returnValue = genl_register_ops(&ptp_events_genl_family, &ptp_events_gnl_ops_heartbeat);
if(returnValue != 0) {
printk(KERN_INFO DRIVER_NAME ": Failed to register Generic Netlink operation\n");
genl_unregister_family(&ptp_events_genl_family);
goto register_failure;
}
/* Register multicast groups */
returnValue = genl_register_mc_group(&ptp_events_genl_family, &rtc_mcast);
if(returnValue != 0) {
printk(KERN_INFO DRIVER_NAME ": Failed to register Generic Netlink multicast group\n");
genl_unregister_ops(&ptp_events_genl_family, &ptp_events_gnl_ops_heartbeat);
genl_unregister_family(&ptp_events_genl_family);
goto register_failure;
}
labx_ptp_netlink_wq = create_workqueue("labx_ptp_netlink");
register_failure:
return(returnValue);
}
/* Generic Netlink Initializaiton */
static int wl_genl_init(void)
{
int ret;
WL_DBG(("GEN Netlink Init\n\n"));
/* register new family */
ret = genl_register_family(&wl_genl_family);
if (ret != 0)
goto failure;
/* register functions (commands) of the new family */
ret = genl_register_ops(&wl_genl_family, &wl_genl_ops);
if (ret != 0) {
WL_ERR(("register ops failed: %i\n", ret));
genl_unregister_family(&wl_genl_family);
goto failure;
}
ret = genl_register_mc_group(&wl_genl_family, &wl_genl_mcast);
if (ret != 0) {
WL_ERR(("register mc_group failed: %i\n", ret));
genl_unregister_ops(&wl_genl_family, &wl_genl_ops);
genl_unregister_family(&wl_genl_family);
goto failure;
}
return 0;
failure:
WL_ERR(("Registering Netlink failed!!\n"));
return -1;
}
static int __init gnKernel_init(void)
{
int rc;
printk("INIT GENERIC NETLINK EXEMPLE MODULE\n");
/*register new family*/
rc = genl_register_family(&doc_exmpl_gnl_family);
if (rc != 0)
goto failure;
/*register functions (commands) of the new family*/
rc = genl_register_ops(&doc_exmpl_gnl_family, &doc_exmpl_gnl_ops_echo);
if (rc != 0){
printk("register ops: %i\n",rc);
genl_unregister_family(&doc_exmpl_gnl_family);
goto failure;
}
return 0;
failure:
printk("an error occured while inserting the generic netlink example module\n");
return -1;
}
static int __init
kfm_genl_register(void)
{
// kernel 3.10.0-229 centos 7.1
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,1,1) /* for kanas (kernel 4.1.1) */
return genl_register_family_with_ops_groups(&kfm_genl_family,
kfm_genl_ops,
kfm_mcgrps);
#else /* for centos 7.0 (kernel 3.10.0) */
{
int ret = 0, i;
ret = genl_register_family_with_ops(&kfm_genl_family,
kfm_genl_ops,
ARRAY_SIZE(kfm_genl_ops));
if (ret)
return -1;
for (i = 0; i < ARRAY_SIZE(kfm_mcgrps); i++) {
ret = genl_register_mc_group(&kfm_genl_family, &kfm_mcgrps[i]);
if (ret) {
genl_unregister_family(&kfm_genl_family);
return -1;
}
}
return 0;
}
#endif
}
static int __init ieee802154_nl_init(void)
{
int rc;
int i;
rc = genl_register_family(&ieee802154_coordinator_family);
if (rc)
goto fail;
rc = genl_register_mc_group(&ieee802154_coordinator_family,
&ieee802154_coord_mcgrp);
if (rc)
goto fail;
rc = genl_register_mc_group(&ieee802154_coordinator_family,
&ieee802154_beacon_mcgrp);
if (rc)
goto fail;
for (i = 0; i < ARRAY_SIZE(ieee802154_coordinator_ops); i++) {
rc = genl_register_ops(&ieee802154_coordinator_family,
&ieee802154_coordinator_ops[i]);
if (rc)
goto fail;
}
return 0;
fail:
genl_unregister_family(&ieee802154_coordinator_family);
return rc;
}
void
vr_genetlink_exit(void)
{
genl_unregister_family(&vrouter_genl_family);
vr_message_transport_unregister(&netlink_transport);
return;
}
void tipc_netlink_stop(void)
{
if (family_registered) {
genl_unregister_family(&family);
family_registered = 0;
}
}
static void __devexit aes3_rx_driver_exit(void)
{
unregister_chrdev_region(MKDEV(DRIVER_MAJOR, 0),MAX_INSTANCES);
/* Unregister as a platform device driver */
platform_driver_unregister(&aes3_rx_driver);
genl_unregister_family(&events_genl_family);
}
void tipc_netlink_stop(void)
{
if (!tipc_genl_family_registered)
return;
genl_unregister_family(&tipc_genl_family);
tipc_genl_family_registered = 0;
}
int
genetlink_unregister(void) {
int ret = 0;
kfree_skb(genl_skb);
ret = genl_unregister_family(&vswitch_flow_family);
return ret;
}
static void brc_cleanup(void)
{
/* Unregister ioctl hooks */
dp_ioctl_hook = NULL;
brioctl_set(NULL);
genl_unregister_family(&brc_genl_family);
brc_procfs_exit();
}
/* 解除注册 */
static void gnrl_unregister()
{
if (genlnet_family.id != GENL_ID_GENERATE) {
/* 这步可以省了 */
genl_unregister_ops(&genlnet_family, &genlnet_msg_trans_ops);
/* 必须 */
genl_unregister_family(&genlnet_family);
}
}
/* Generic netlink deinit */
static int wl_genl_deinit(void)
{
if (genl_unregister_ops(&wl_genl_family, &wl_genl_ops) < 0)
WL_ERR(("Unregister wl_genl_ops failed\n"));
if (genl_unregister_family(&wl_genl_family) < 0)
WL_ERR(("Unregister wl_genl_ops failed\n"));
return 0;
}
/* Shutdown the wimax stack */
static
void __exit wimax_subsys_exit(void)
{
int cnt;
wimax_id_table_release();
genl_unregister_mc_group(&wimax_gnl_family, &wimax_gnl_mcg);
for (cnt = ARRAY_SIZE(wimax_gnl_ops) - 1; cnt >= 0; cnt--)
genl_unregister_ops(&wimax_gnl_family,
wimax_gnl_ops[cnt]);
genl_unregister_family(&wimax_gnl_family);
}
void seg6_exit(void)
{
#ifdef CONFIG_IPV6_SEG6_HMAC
seg6_hmac_exit();
#endif
#ifdef CONFIG_IPV6_SEG6_LWTUNNEL
seg6_iptunnel_exit();
#endif
unregister_pernet_subsys(&ip6_segments_ops);
genl_unregister_family(&seg6_genl_family);
}
void unregister_ptp_netlink(void) {
if (NULL != labx_ptp_netlink_wq) {
destroy_workqueue(labx_ptp_netlink_wq);
labx_ptp_netlink_wq = NULL;
}
/* Unregister operations and the family */
genl_unregister_ops(&ptp_events_genl_family, &ptp_events_gnl_ops_heartbeat);
genl_unregister_family(&ptp_events_genl_family);
}
static void __exit nlk_exit(void)
{
int ret;
printk("nlk_exit\n");
/* unregister the family */
ret = genl_unregister_family(&demo_gnl_family);
if (ret != 0) {
printk("unregister family %i\n", ret);
}
}
/*----------------------------------------------------------------------------*/
VOID
glResetUninit(
VOID
)
{
/* 1. release NETLINK_GENERIC family */
genl_unregister_family(&mtk_wifi_gnl_family);
/* 2. deregister for reset callback */
mtk_wcn_wmt_msgcb_unreg(WMTDRV_TYPE_WIFI);
return;
}
static void __exit exmpl_gnl_exit(void)
{
int ret;
/*unregister the functions*/
ret = genl_unregister_ops(&exmpl_gnl_family, &exmpl_gnl_ops_echo);
if(ret != 0){
printk("unregister ops: %i\n",ret);
return;
}
/*unregister the family*/
ret = genl_unregister_family(&exmpl_gnl_family);
if(ret !=0){
printk("unregister family %i\n",ret);
}
}
/*----------------------------------------------------------------------------*/
VOID
glResetUninit(
VOID
)
{
/* 1. release NETLINK_GENERIC family */
genl_unregister_family(&mtk_wifi_gnl_family);
#if (MTK_WCN_SINGLE_MODULE == 0)
/* 2. deregister for reset callback */
mtk_wcn_wmt_msgcb_unreg(WMTDRV_TYPE_WIFI);
#endif /* MTK_WCN_SINGLE_MODULE */
return;
}
static int __init brc_init(void)
{
int err;
printk("Open vSwitch Bridge Compatibility, built "__DATE__" "__TIME__"\n");
/* Set the bridge ioctl handler */
brioctl_set(brc_ioctl_deviceless_stub);
/* Set the openvswitch_mod device ioctl handler */
dp_ioctl_hook = brc_dev_ioctl;
/* Randomize the initial sequence number. This is not a security
* feature; it only helps avoid crossed wires between userspace and
* the kernel when the module is unloaded and reloaded. */
brc_seq = net_random();
/* Register generic netlink family to communicate changes to
* userspace. */
err = genl_register_family(&brc_genl_family);
if (err)
goto error;
err = genl_register_ops(&brc_genl_family, &brc_genl_ops_query_dp);
if (err != 0)
goto err_unregister;
err = genl_register_ops(&brc_genl_family, &brc_genl_ops_dp_result);
if (err != 0)
goto err_unregister;
err = genl_register_ops(&brc_genl_family, &brc_genl_ops_set_proc);
if (err != 0)
goto err_unregister;
strcpy(brc_mc_group.name, "brcompat");
err = genl_register_mc_group(&brc_genl_family, &brc_mc_group);
if (err < 0)
goto err_unregister;
return 0;
err_unregister:
genl_unregister_family(&brc_genl_family);
error:
pr_emerg("failed to install!\n");
return err;
}
/* Shutdown the wimax stack */
static
int __init wimax_subsys_init(void)
{
int result, cnt;
d_fnstart(4, NULL, "()\n");
d_parse_params(D_LEVEL, D_LEVEL_SIZE, wimax_debug_params,
"wimax.debug");
snprintf(wimax_gnl_family.name, sizeof(wimax_gnl_family.name),
"WiMAX");
result = genl_register_family(&wimax_gnl_family);
if (unlikely(result < 0)) {
printk(KERN_ERR "cannot register generic netlink family: %d\n",
result);
goto error_register_family;
}
for (cnt = 0; cnt < ARRAY_SIZE(wimax_gnl_ops); cnt++) {
result = genl_register_ops(&wimax_gnl_family,
wimax_gnl_ops[cnt]);
d_printf(4, NULL, "registering generic netlink op code "
"%u: %d\n", wimax_gnl_ops[cnt]->cmd, result);
if (unlikely(result < 0)) {
printk(KERN_ERR "cannot register generic netlink op "
"code %u: %d\n",
wimax_gnl_ops[cnt]->cmd, result);
goto error_register_ops;
}
}
result = genl_register_mc_group(&wimax_gnl_family, &wimax_gnl_mcg);
if (result < 0)
goto error_mc_group;
d_fnend(4, NULL, "() = 0\n");
return 0;
error_mc_group:
error_register_ops:
for (cnt--; cnt >= 0; cnt--)
genl_unregister_ops(&wimax_gnl_family,
wimax_gnl_ops[cnt]);
genl_unregister_family(&wimax_gnl_family);
error_register_family:
d_fnend(4, NULL, "() = %d\n", result);
return result;
}
int __init dlm_netlink_init(void)
{
int rv;
rv = genl_register_family(&family);
if (rv)
return rv;
rv = genl_register_ops(&family, &dlm_nl_ops);
if (rv < 0)
goto err;
return 0;
err:
genl_unregister_family(&family);
return rv;
}
static void __exit gnKernel_exit(void)
{
int ret;
printk("EXIT GENERIC NETLINK EXEMPLE MODULE\n");
/*unregister the functions*/
ret = genl_unregister_ops(&doc_exmpl_gnl_family, &doc_exmpl_gnl_ops_echo);
if(ret != 0){
printk("unregister ops: %i\n",ret);
return;
}
/*unregister the family*/
ret = genl_unregister_family(&doc_exmpl_gnl_family);
if(ret !=0){
printk("unregister family %i\n",ret);
}
}
int wl1251_nl_register(void)
{
int err, i;
err = genl_register_family(&wl1251_nl_family);
if (err)
return err;
for (i = 0; i < ARRAY_SIZE(wl1251_nl_ops); i++) {
err = genl_register_ops(&wl1251_nl_family, &wl1251_nl_ops[i]);
if (err)
goto err_out;
}
return 0;
err_out:
genl_unregister_family(&wl1251_nl_family);
return err;
}
int register_netlink(void) {
int ret;
// register new family
ret = genl_register_family(&ca_family);
if (ret) {
printk("dvbsoftwareca: genl_register_family error\n");
return ret;
}
// register functions (commands) of the new family
ret = genl_register_ops(&ca_family, &ask_ca_size_ops);
if (ret) {
genl_unregister_family(&ca_family);
printk("dvbsoftwareca: genl_register_family error\n");
}
return ret;
}
/**
* genl_register_family_with_ops - register a generic netlink family
* @family: generic netlink family
* @ops: operations to be registered
* @n_ops: number of elements to register
*
* Registers the specified family and operations from the specified table.
* Only one family may be registered with the same family name or identifier.
*
* The family id may equal GENL_ID_GENERATE causing an unique id to
* be automatically generated and assigned.
*
* Either a doit or dumpit callback must be specified for every registered
* operation or the function will fail. Only one operation structure per
* command identifier may be registered.
*
* See include/net/genetlink.h for more documenation on the operations
* structure.
*
* This is equivalent to calling genl_register_family() followed by
* genl_register_ops() for every operation entry in the table taking
* care to unregister the family on error path.
*
* Return 0 on success or a negative error code.
*/
int genl_register_family_with_ops(struct genl_family *family,
struct genl_ops *ops, size_t n_ops)
{
int err, i;
err = genl_register_family(family);
if (err)
return err;
for (i = 0; i < n_ops; ++i, ++ops) {
err = genl_register_ops(family, ops);
if (err)
goto err_out;
}
return 0;
err_out:
genl_unregister_family(family);
return err;
}
/* 创建一个netlink */
static int gnrl_register()
{
int ret;
ret = genl_register_family(&genlnet_family);
if (ret < 0) {
printk(KERN_ERR "%s %d: ret = %d\n", __func__, __LINE__, ret);
return -1;
}
ret = genl_register_ops(&genlnet_family, &genlnet_msg_trans_ops);
if (ret < 0) {
printk(KERN_ERR "%s %d: ret = %d\n", __func__, __LINE__, ret);
genl_unregister_family(&genlnet_family);
return -1;
}
return 0;
}
int __init seg6_init(void)
{
int err = -ENOMEM;
err = genl_register_family(&seg6_genl_family);
if (err)
goto out;
err = register_pernet_subsys(&ip6_segments_ops);
if (err)
goto out_unregister_genl;
#ifdef CONFIG_IPV6_SEG6_LWTUNNEL
err = seg6_iptunnel_init();
if (err)
goto out_unregister_pernet;
#endif
#ifdef CONFIG_IPV6_SEG6_HMAC
err = seg6_hmac_init();
if (err)
goto out_unregister_iptun;
#endif
pr_info("Segment Routing with IPv6\n");
out:
return err;
#ifdef CONFIG_IPV6_SEG6_HMAC
out_unregister_iptun:
#ifdef CONFIG_IPV6_SEG6_LWTUNNEL
seg6_iptunnel_exit();
#endif
#endif
#ifdef CONFIG_IPV6_SEG6_LWTUNNEL
out_unregister_pernet:
unregister_pernet_subsys(&ip6_segments_ops);
#endif
out_unregister_genl:
genl_unregister_family(&seg6_genl_family);
goto out;
}
static int __init exmpl_gnl_init(void)
{
int rc;
rc = genl_register_family(&exmpl_gnl_family);
if (rc != 0) {
printk(KERN_INFO "rkmod: genl_register_family failed %d\n", rc);
return 1;
}
/* genl_register_ops requires old kernels, on latest kernels use
* genl_register_family_with_ops
*/
rc = genl_register_ops(&exmpl_gnl_family, &exmpl_gnl_ops_echo);
if (rc != 0) {
printk(KERN_INFO "rkmod: genl_register_ops failed %d\n", rc);
genl_unregister_family(&exmpl_gnl_family);
return -1;
}
printk(KERN_INFO "Generic netlink example loaded, protocol version %d\n", VERSION_NR);
return 0;
}
