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;
}
/* 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;
}
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);
}
static int register_family(void)
{
int error;
log_debug("Registering Generic Netlink family...");
strcpy(jool_family.name, GNL_JOOL_FAMILY_NAME);
#if LINUX_VERSION_LOWER_THAN(3, 13, 0, 7, 1)
error = genl_register_family_with_ops(&jool_family, ops, ARRAY_SIZE(ops));
if (error) {
log_err("Couldn't register family!");
return error;
}
error = genl_register_mc_group(&jool_family, &(mc_groups[0]));
if (error) {
log_err("Couldn't register multicast group!");
return error;
}
#else
error = genl_register_family_with_ops_groups(&jool_family, ops, mc_groups);
if (error) {
log_err("Family registration failed: %d", error);
return error;
}
#endif
nlcore_init(&jool_family, &mc_groups[0]);
return 0;
}
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
}
/*
* No need to unregister as family unregistration will do it.
*/
int nl802154_mac_register(void)
{
int i;
int rc;
rc = genl_register_mc_group(&nl802154_family,
&ieee802154_coord_mcgrp);
if (rc)
return rc;
rc = genl_register_mc_group(&nl802154_family,
&ieee802154_beacon_mcgrp);
if (rc)
return rc;
for (i = 0; i < ARRAY_SIZE(ieee802154_coordinator_ops); i++) {
rc = genl_register_ops(&nl802154_family,
&ieee802154_coordinator_ops[i]);
if (rc)
return rc;
}
return 0;
}
/* 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;
}
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;
}
int __backport_genl_register_family(struct genl_family *family)
{
int i, ret;
#define __copy(_field) family->family._field = family->_field
__copy(id);
__copy(hdrsize);
__copy(version);
__copy(maxattr);
strncpy(family->family.name, family->name, sizeof(family->family.name));
__copy(netnsok);
__copy(pre_doit);
__copy(post_doit);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)
__copy(parallel_ops);
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0)
__copy(module);
#endif
#undef __copy
ret = genl_register_family(&family->family);
if (ret < 0)
return ret;
family->attrbuf = family->family.attrbuf;
family->id = family->family.id;
for (i = 0; i < family->n_ops; i++) {
ret = genl_register_ops(&family->family, &family->ops[i]);
if (ret < 0)
goto error;
}
for (i = 0; i < family->n_mcgrps; i++) {
ret = genl_register_mc_group(&family->family,
&family->mcgrps[i]);
if (ret)
goto error;
}
return 0;
error:
backport_genl_unregister_family(family);
return ret;
}
/* Driver initialization and exit */
static int __devinit aes3_rx_driver_init(void)
{
int returnValue;
printk(KERN_INFO DRIVER_NAME ": AES3 Receiver driver\n");
printk(KERN_INFO DRIVER_NAME ": Copyright(c) Lab X Technologies, LLC\n");
#ifdef CONFIG_OF
returnValue = of_register_platform_driver(&of_aes3_rx_driver);
#endif
instanceCount = 0;
/* Register as a platform device driver */
if((returnValue = platform_driver_register(&aes3_rx_driver)) < 0) {
printk(KERN_INFO DRIVER_NAME ": Failed to register platform driver\n");
goto register_failure;
}
if((returnValue = register_chrdev_region(MKDEV(DRIVER_MAJOR, 0),MAX_INSTANCES, DRIVER_NAME)) < 0) {
printk(KERN_INFO DRIVER_NAME "Failed to allocate character device range\n");
goto register_failure;
}
/* Register the Generic Netlink family for use */
returnValue = genl_register_family(&events_genl_family);
if(returnValue != 0) {
printk(KERN_INFO DRIVER_NAME ": Failed to register Generic Netlink family\n");
goto register_failure;
}
/* Register multicast groups */
returnValue = genl_register_mc_group(&events_genl_family, &labx_aes_mcast);
if(returnValue != 0) {
printk(KERN_INFO DRIVER_NAME ": Failed to register Generic Netlink multicast group\n");
genl_unregister_family(&events_genl_family);
goto register_failure;
}
register_failure:
return(returnValue);
}
