void kset_test_exit(void)
{
printk("kset test exit:\n");
kset_unregister(&kset_p);
kset_unregister(&kset_c);
}
/**
* bus_unregister - remove a bus from the system
* @bus: bus.
*
* Unregister the child subsystems and the bus itself.
* Finally, we call put_bus() to release the refcount
*/
void bus_unregister(struct bus_type * bus)
{
pr_debug("bus %s: unregistering\n", bus->name);
bus_remove_attrs(bus);
kset_unregister(&bus->drivers);
kset_unregister(&bus->devices);
subsystem_unregister(&bus->subsys);
}
static void _destroy_iostash_kobjects(void)
{
kobject_del(&gctx.ctl_kobj);
kobject_put(&gctx.ctl_kobj);
kset_unregister(gctx.ssd_kset);
kset_unregister(gctx.hdd_kset);
return;
}
/**
* bus_unregister - remove a bus from the system
* @bus: bus.
*
* Unregister the child subsystems and the bus itself.
* Finally, we call put_bus() to release the refcount
*/
void bus_unregister(struct bus_type * bus)
{
pr_debug("bus %s: unregistering\n", bus->name);
free_notifier_for_bus(bus);
bus_remove_attrs(bus);
remove_probe_files(bus);
kset_unregister(&bus->drivers);
kset_unregister(&bus->devices);
subsystem_unregister(&bus->subsys);
}
/**
* bus_unregister - remove a bus from the system
* @bus: bus.
*
* Unregister the child subsystems and the bus itself.
* Finally, we call bus_put() to release the refcount
*/
void bus_unregister(struct bus_type *bus)
{
pr_debug("bus: '%s': unregistering\n", bus->name);
bus_remove_attrs(bus);
remove_probe_files(bus);
kset_unregister(bus->p->drivers_kset);
kset_unregister(bus->p->devices_kset);
bus_remove_file(bus, &bus_attr_uevent);
kset_unregister(&bus->p->subsys);
kfree(bus->p);
}
/**
* bus_register - register a bus with the system.
* @bus: bus.
*
* Once we have that, we registered the bus with the kobject
* infrastructure, then register the children subsystems it has:
* the devices and drivers that belong to the bus.
*/
int bus_register(struct bus_type * bus)
{
int retval = -ENOMEM;
struct blocking_notifier_head *notifier_head;
notifier_head = alloc_save_notifier_for_bus(bus);
if (!notifier_head)
goto out;
BLOCKING_INIT_NOTIFIER_HEAD(notifier_head);
retval = kobject_set_name(&bus->subsys.kset.kobj, "%s", bus->name);
if (retval)
goto out;
subsys_set_kset(bus, bus_subsys);
retval = subsystem_register(&bus->subsys);
if (retval)
goto out;
kobject_set_name(&bus->devices.kobj, "devices");
bus->devices.subsys = &bus->subsys;
retval = kset_register(&bus->devices);
if (retval)
goto bus_devices_fail;
kobject_set_name(&bus->drivers.kobj, "drivers");
bus->drivers.subsys = &bus->subsys;
bus->drivers.ktype = &ktype_driver;
retval = kset_register(&bus->drivers);
if (retval)
goto bus_drivers_fail;
klist_init(&bus->klist_devices, klist_devices_get, klist_devices_put);
klist_init(&bus->klist_drivers, klist_drivers_get, klist_drivers_put);
retval = add_probe_files(bus);
if (retval)
goto bus_probe_files_fail;
bus_add_attrs(bus);
pr_debug("bus type '%s' registered\n", bus->name);
return 0;
bus_probe_files_fail:
kset_unregister(&bus->drivers);
bus_drivers_fail:
kset_unregister(&bus->devices);
bus_devices_fail:
subsystem_unregister(&bus->subsys);
out:
return retval;
}
void remove_gc_sysfs_file(struct platform_device *pdev)
{
if(!galDevice)
return;
if(!kset_gpu)
return;
if(registered_pm_test)
{
remove_sysfs_file_pm_test(pdev);
registered_pm_test = 0;
}
if(registered_gpufreq)
{
__remove_sysfs_file_gpufreq();
registered_gpufreq = 0;
}
if(registered_debug)
{
__remove_sysfs_file_debug();
registered_debug = 0;
}
if(registered_common)
{
__remove_sysfs_file_common();
registered_common = 0;
}
/* release a kset. */
kset_unregister(kset_gpu);
}
int o2cb_sys_init(void)
{
int ret;
o2cb_kset = kset_create_and_add("o2cb", NULL, fs_kobj);
if (!o2cb_kset)
return -ENOMEM;
/*
* Create this symlink for backwards compatibility with old
* versions of ocfs2-tools which look for things in /sys/o2cb.
*/
ret = sysfs_create_link(NULL, &o2cb_kset->kobj, "o2cb");
if (ret)
goto error;
ret = sysfs_create_group(&o2cb_kset->kobj, &o2cb_attr_group);
if (ret)
goto error;
ret = mlog_sys_init(o2cb_kset);
if (ret)
goto error;
return 0;
error:
kset_unregister(o2cb_kset);
return ret;
}
int __init sysaufs_init(void)
{
int err;
do {
get_random_bytes(&sysaufs_si_mask, sizeof(sysaufs_si_mask));
} while (!sysaufs_si_mask);
err = -EINVAL;
sysaufs_kset = kset_create_and_add(AUFS_NAME, NULL, fs_kobj);
if (unlikely(!sysaufs_kset))
goto out;
err = PTR_ERR(sysaufs_kset);
if (IS_ERR(sysaufs_kset))
goto out;
err = sysfs_create_group(&sysaufs_kset->kobj, sysaufs_attr_group);
if (unlikely(err)) {
kset_unregister(sysaufs_kset);
goto out;
}
err = dbgaufs_init();
if (unlikely(err))
sysaufs_fin();
out:
return err;
}
void f2fs_exit_sysfs(void)
{
kobject_put(&f2fs_feat);
kset_unregister(&f2fs_kset);
remove_proc_entry("fs/f2fs", NULL);
f2fs_proc_root = NULL;
}
static void __exit
pdc_stable_exit(void)
{
pdcs_unregister_pathentries();
kset_unregister(paths_kset);
kobject_put(stable_kobj);
}
static void __exit example_exit(void)
{
destroy_foo_obj(baz_obj);
destroy_foo_obj(bar_obj);
destroy_foo_obj(foo_obj);
kset_unregister(example_kset);
}
/**
* bus_register - register a bus with the system.
* @bus: bus.
*
* Once we have that, we registered the bus with the kobject
* infrastructure, then register the children subsystems it has:
* the devices and drivers that belong to the bus.
*/
int bus_register(struct bus_type * bus)
{
int retval;
BLOCKING_INIT_NOTIFIER_HEAD(&bus->bus_notifier);
retval = kobject_set_name(&bus->subsys.kset.kobj, "%s", bus->name);
if (retval)
goto out;
subsys_set_kset(bus, bus_subsys);
retval = subsystem_register(&bus->subsys);
if (retval)
goto out;
kobject_set_name(&bus->devices.kobj, "devices");
bus->devices.subsys = &bus->subsys;
retval = kset_register(&bus->devices);
if (retval)
goto bus_devices_fail;
kobject_set_name(&bus->drivers.kobj, "drivers");
bus->drivers.subsys = &bus->subsys;
bus->drivers.ktype = &ktype_driver;
retval = kset_register(&bus->drivers);
if (retval)
goto bus_drivers_fail;
klist_init(&bus->klist_devices, klist_devices_get, klist_devices_put);
klist_init(&bus->klist_drivers, NULL, NULL);
retval = bus_add_attrs(bus);
if (retval)
goto bus_attrs_fail;
pr_debug("bus type '%s' registered\n", bus->name);
return 0;
bus_attrs_fail:
kset_unregister(&bus->drivers);
bus_drivers_fail:
kset_unregister(&bus->devices);
bus_devices_fail:
subsystem_unregister(&bus->subsys);
out:
return retval;
}
static void __exit pcrypt_exit(void)
{
pcrypt_fini_padata(&pencrypt);
pcrypt_fini_padata(&pdecrypt);
kset_unregister(pcrypt_kset);
crypto_unregister_template(&pcrypt_tmpl);
}
static void __exit exit(void)
{
printk(KERN_INFO "exit\n");
destroy_utility_obj(force_cache_obj);
destroy_utility_obj(enumer_page_obj);
destroy_utility_obj(add_range_obj);
kset_unregister(utility_kset);
}
static void kobj_demo_exit(void)
{
sysfs_remove_file(child, &cld_att);
kset_unregister(c_kset);
kobject_del(child);
kobject_del(parent);
}
static int __init init_f2fs_fs(void)
{
int err;
f2fs_build_trace_ios();
err = init_inodecache();
if (err)
goto fail;
err = create_node_manager_caches();
if (err)
goto free_inodecache;
err = create_segment_manager_caches();
if (err)
goto free_node_manager_caches;
err = create_checkpoint_caches();
if (err)
goto free_segment_manager_caches;
err = create_extent_cache();
if (err)
goto free_checkpoint_caches;
f2fs_kset = kset_create_and_add("f2fs", NULL, fs_kobj);
if (!f2fs_kset) {
err = -ENOMEM;
goto free_extent_cache;
}
err = register_shrinker(&f2fs_shrinker_info);
if (err)
goto free_kset;
err = register_filesystem(&f2fs_fs_type);
if (err)
goto free_shrinker;
err = f2fs_create_root_stats();
if (err)
goto free_filesystem;
f2fs_proc_root = proc_mkdir("fs/f2fs", NULL);
return 0;
free_filesystem:
unregister_filesystem(&f2fs_fs_type);
free_shrinker:
unregister_shrinker(&f2fs_shrinker_info);
free_kset:
kset_unregister(f2fs_kset);
free_extent_cache:
destroy_extent_cache();
free_checkpoint_caches:
destroy_checkpoint_caches();
free_segment_manager_caches:
destroy_segment_manager_caches();
free_node_manager_caches:
destroy_node_manager_caches();
free_inodecache:
destroy_inodecache();
fail:
return err;
}
/*
* For now we register the stable subsystem with the firmware subsystem
* and the paths subsystem with the stable subsystem
*/
static int __init
pdc_stable_init(void)
{
int rc = 0, error = 0;
u32 result;
/* find the size of the stable storage */
if (pdc_stable_get_size(&pdcs_size) != PDC_OK)
return -ENODEV;
/* make sure we have enough data */
if (pdcs_size < 96)
return -ENODATA;
printk(KERN_INFO PDCS_PREFIX " facility v%s\n", PDCS_VERSION);
/* get OSID */
if (pdc_stable_read(PDCS_ADDR_OSID, &result, sizeof(result)) != PDC_OK)
return -EIO;
/* the actual result is 16 bits away */
pdcs_osid = (u16)(result >> 16);
/* For now we'll register the directory at /sys/firmware/stable */
stable_kobj = kobject_create_and_add("stable", firmware_kobj);
if (!stable_kobj) {
rc = -ENOMEM;
goto fail_firmreg;
}
/* Don't forget the root entries */
error = sysfs_create_group(stable_kobj, &pdcs_attr_group);
/* register the paths kset as a child of the stable kset */
paths_kset = kset_create_and_add("paths", NULL, stable_kobj);
if (!paths_kset) {
rc = -ENOMEM;
goto fail_ksetreg;
}
/* now we create all "files" for the paths kset */
if ((rc = pdcs_register_pathentries()))
goto fail_pdcsreg;
return rc;
fail_pdcsreg:
pdcs_unregister_pathentries();
kset_unregister(paths_kset);
fail_ksetreg:
kobject_put(stable_kobj);
fail_firmreg:
printk(KERN_INFO PDCS_PREFIX " bailing out\n");
return rc;
}
/*
* clean up on module removal
*/
static void __exit fscache_exit(void)
{
_enter("");
kset_unregister(&fscache_kset);
kmem_cache_destroy(fscache_cookie_jar);
printk(KERN_NOTICE "FS-Cache: unloaded\n");
}
static int __init
pdc_stable_init(void)
{
int rc = 0, error = 0;
u32 result;
if (pdc_stable_get_size(&pdcs_size) != PDC_OK)
return -ENODEV;
if (pdcs_size < 96)
return -ENODATA;
printk(KERN_INFO PDCS_PREFIX " facility v%s\n", PDCS_VERSION);
if (pdc_stable_read(PDCS_ADDR_OSID, &result, sizeof(result)) != PDC_OK)
return -EIO;
pdcs_osid = (u16)(result >> 16);
stable_kobj = kobject_create_and_add("stable", firmware_kobj);
if (!stable_kobj) {
rc = -ENOMEM;
goto fail_firmreg;
}
error = sysfs_create_group(stable_kobj, &pdcs_attr_group);
paths_kset = kset_create_and_add("paths", NULL, stable_kobj);
if (!paths_kset) {
rc = -ENOMEM;
goto fail_ksetreg;
}
if ((rc = pdcs_register_pathentries()))
goto fail_pdcsreg;
return rc;
fail_pdcsreg:
pdcs_unregister_pathentries();
kset_unregister(paths_kset);
fail_ksetreg:
kobject_put(stable_kobj);
fail_firmreg:
printk(KERN_INFO PDCS_PREFIX " bailing out\n");
return rc;
}
int hw_btn_object_exit(void)
{
destroy_hw_btn_obj(reset_btn_obj);
destroy_hw_btn_obj(alarm_silent_btn_obj);
destroy_hw_btn_obj(tamper_obj);
destroy_hw_btn_obj(tamper_history_obj);
destroy_hw_btn_obj(hw_id_obj);
kset_unregister(smartly_kset);
return 0;
}
static void __exit exit_f2fs_fs(void)
{
remove_proc_entry("fs/f2fs", NULL);
f2fs_destroy_root_stats();
unregister_filesystem(&f2fs_fs_type);
destroy_checkpoint_caches();
destroy_gc_caches();
destroy_node_manager_caches();
destroy_inodecache();
kset_unregister(f2fs_kset);
}
static int _init_iostash_kobjects(void)
{
int err = 0;
static struct kobj_type ctl_kobj_type = {
.release = ctl_kobj_release,
.sysfs_ops = &ctl_sysfs_ops,
.default_attrs = ctl_attrs,
};
memset(&gctx.ctl_kobj, 0, sizeof(gctx.ctl_kobj));
kobject_init(&gctx.ctl_kobj, &ctl_kobj_type);
err = kobject_add(&gctx.ctl_kobj,
(&(THIS_MODULE)->mkobj.kobj),
"%s",
CTL_KOBJ_NAME);
if (err)
{
kobject_put(&gctx.ctl_kobj);
err = -ENOMEM;
goto out;
}
gctx.ssd_kset = kset_create_and_add
(SSD_KSET_NAME, NULL, (&(THIS_MODULE)->mkobj.kobj));
if (!gctx.ssd_kset)
{
err = -ENOMEM;
goto kobj_del;
}
gctx.hdd_kset = kset_create_and_add
(HDD_KSET_NAME, NULL, (&(THIS_MODULE)->mkobj.kobj));
if (!gctx.hdd_kset)
{
err = -ENOMEM;
goto unreg_ssd_kset;
}
BUG_ON(0 != err);
return 0;
kobj_del:
kobject_del(&gctx.ctl_kobj);
kobject_put(&gctx.ctl_kobj);
unreg_ssd_kset:
kset_unregister(gctx.ssd_kset);
out:
return err;
}
static void release_hdmi_obj(void)
{
if (cb_hdmi_notifier) {
cb_delete_hdmi_obj(cb_hdmi_notifier);
cb_hdmi_notifier = NULL;
}
if (cb_hdmi_kset) {
kset_unregister(cb_hdmi_kset);
cb_hdmi_kset = NULL;
}
}
static void __exit inv_pthread_exit(void)
{
thread_control_set(0);
/* Delay for guarantee thread exit */
ssleep(THREAD_DELAY_MINS);
sysfs_remove_file(status_kobj, &status_att);
kset_unregister(status_kset);
kobject_del(status_kobj);
printk(KERN_INFO "[p_thread] inv_pthread cleaning Up\n");
}
static void efivars_sysfs_exit(void)
{
/* Remove all entries and destroy */
__efivar_entry_iter(efivar_sysfs_destroy, &efivar_sysfs_list, NULL, NULL);
if (efivars_new_var)
sysfs_remove_bin_file(&efivars_kset->kobj, efivars_new_var);
if (efivars_del_var)
sysfs_remove_bin_file(&efivars_kset->kobj, efivars_del_var);
kfree(efivars_new_var);
kfree(efivars_del_var);
kset_unregister(efivars_kset);
}
static void __exit visdn_module_exit(void)
{
visdn_port_modexit();
class_unregister(&visdn_system_class);
device_unregister(&visdn_system_device);
unregister_chrdev_region(visdn_first_dev, 2);
kset_unregister(visdn_kset);
visdn_kset = NULL;
visdn_msg(KERN_INFO, "unloaded\n");
}
static void __exit exit_f2fs_fs(void)
{
remove_proc_entry("fs/f2fs", NULL);
f2fs_destroy_root_stats();
unregister_shrinker(&f2fs_shrinker_info);
unregister_filesystem(&f2fs_fs_type);
f2fs_exit_crypto();
destroy_extent_cache();
destroy_checkpoint_caches();
destroy_segment_manager_caches();
destroy_node_manager_caches();
destroy_inodecache();
kset_unregister(f2fs_kset);
f2fs_destroy_trace_ios();
}
static void __exit lustre_exit(void)
{
lustre_register_super_ops(NULL, NULL, NULL);
lustre_register_client_process_config(NULL);
debugfs_remove(llite_root);
kset_unregister(llite_kset);
ll_xattr_fini();
cl_env_put(cl_inode_fini_env, &cl_inode_fini_refcheck);
vvp_global_fini();
kmem_cache_destroy(ll_inode_cachep);
kmem_cache_destroy(ll_file_data_slab);
}
static int __init pcrypt_init(void)
{
int err = -ENOMEM;
pcrypt_kset = kset_create_and_add("pcrypt", NULL, kernel_kobj);
if (!pcrypt_kset)
goto err;
err = pcrypt_init_padata(&pencrypt, "pencrypt");
if (err)
goto err_unreg_kset;
err = pcrypt_init_padata(&pdecrypt, "pdecrypt");
if (err)
goto err_deinit_pencrypt;
padata_start(pencrypt.pinst);
padata_start(pdecrypt.pinst);
return crypto_register_template(&pcrypt_tmpl);
err_deinit_pencrypt:
pcrypt_fini_padata(&pencrypt);
err_unreg_kset:
kset_unregister(pcrypt_kset);
err:
return err;
}
