static void mtd_notify_remove(struct mtd_info* mtd)
{
if (!mtd)
return;
devfs_remove("mtd/%d", mtd->index);
devfs_remove("mtd/%dro", mtd->index);
}
static void __exit adc_exit(void)
{
#ifdef CONFIG_DEVFS_FS
devfs_remove("adc/%d", 0);
devfs_remove("adc");
#endif
iounmap(peter_base_addr);
unregister_chrdev(adc_major,DEVICE_NAME);
printk("i am adc_exit, you see me, which means the module is rmmoved\n");
}
static void __exit raw_exit(void)
{
int i;
for (i = 1; i < MAX_RAW_MINORS; i++)
devfs_remove("raw/raw%d", i);
devfs_remove("raw/rawctl");
devfs_remove("raw");
cdev_del(&raw_cdev);
unregister_chrdev_region(MKDEV(RAW_MAJOR, 0), MAX_RAW_MINORS);
}
void cleanup_module(void)
{
/*
* Unregister the device
*/
devfs_remove("dvb/adapter0/frontend0");
class_simple_device_remove(MKDEV(DVB_MAJOR, 3));
devfs_remove("dvb");
class_simple_destroy(my_class);
cdev_del(&device_cdev);
unregister_chrdev_region(MKDEV(DVB_MAJOR, 0), 64);
printk(KERN_INFO "[td-dvb-fe] unload successful\n");
}
void
ddi_remove_minor_node(dev_info_t *dip, char *name)
{
//printf("zvol: remove minor: '%s'\n", name ? name : "");
if (dip->devc) {
devfs_remove(dip->devc);
dip->devc = NULL;
}
if (dip->devb) {
devfs_remove(dip->devb);
dip->devb = NULL;
}
}
static void mtd_notify_remove(struct mtd_info* mtd)
{
if (!mtd)
return;
#ifdef CONFIG_DEVFS_FS
devfs_remove("mtd/%d", mtd->index);
devfs_remove("mtd/%dro", mtd->index);
#else
class_device_destroy(mtd_class, MKDEV(MTD_CHAR_MAJOR, mtd->index*2));
class_device_destroy(mtd_class, MKDEV(MTD_CHAR_MAJOR, mtd->index*2+1));
#endif
}
void devfs_remove_disk(struct gendisk *disk)
{
if (disk->minors != 1) {
devfs_remove("discs/disc%d", disk->number);
dealloc_unique_number(&disc_numspace, disk->number);
devfs_remove("%s/disc", disk->devfs_name);
}
if (disk->flags & GENHD_FL_CD) {
devfs_remove("cdroms/cdrom%d", disk->number);
dealloc_unique_number(&cdrom_numspace, disk->number);
}
devfs_remove(disk->devfs_name);
}
static void devfs_unregister_card(struct em84xx *card)
{
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,69)
devfs_unregister(em8300_handle[0]);
devfs_unregister(em8300_handle[1]);
devfs_unregister(em8300_handle[2]);
devfs_unregister(em8300_handle[3]);
#else
devfs_remove("%s%d", REALMAGIC_DEVICE_NAME, 0);
devfs_remove("%s%d", REALMAGIC_DEVICE_NAME, 1);
devfs_remove("%s%d", REALMAGIC_DEVICE_NAME, 2);
devfs_remove("%s%d", REALMAGIC_DEVICE_NAME, 3);
#endif
}
static void __exit bpp_cleanup(void)
{
unsigned idx;
for (idx = 0; idx < BPP_NO; idx++)
devfs_remove("bpp/%d", idx);
devfs_remove("bpp");
unregister_chrdev(BPP_MAJOR, dev_name);
for (idx = 0; idx < BPP_NO; idx++) {
if (instances[idx].present)
freeLptPort(idx);
}
}
/**
* ubi_free_volume - free volume.
* @ubi: UBI device description object
* @vol: volume description object
*
* This function frees all resources for volume @vol but does not remove it.
* Used only when the UBI device is detached.
*/
void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol)
{
dbg_gen("free volume %d", vol->vol_id);
ubi->volumes[vol->vol_id] = NULL;
devfs_remove(&vol->cdev);
}
static void lpp_remove_one (struct pci_dev *pdev)
{
DEV *dev = pci_get_drvdata(pdev);
dbg("%s(): dev=%08X pci_dev->vendor=%04X device=%04X",
__FUNCTION__, (uint)dev,
pdev->vendor, pdev->device);
if (!dev) BUG();
down (&minor_table_mutex);
#ifdef CONFIG_DEVFS_FS
devfs_remove("lpc/%d", dev->minor);
#endif
minor_table[dev->minor] = NULL;
// unregister_netdev(dev);
// iounmap(cp->regs);
pci_release_regions(pdev);
pci_clear_mwi(pdev);
pci_disable_device(pdev);
pci_set_drvdata(pdev, NULL);
tasklet_kill(&dev->Dpc);
kfree(dev);
info(DRIVER_DESC " " DRIVER_DEV_NAME "%d now disconnected", dev->minor);
up (&minor_table_mutex);
}
/**
* uif_init - initialize user interfaces for an UBI device.
* @ubi: UBI device description object
* @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was
* taken, otherwise set to %0
*
* This function initializes various user interfaces for an UBI device. If the
* initialization fails at an early stage, this function frees all the
* resources it allocated, returns an error, and @ref is set to %0. However,
* if the initialization fails after the UBI device was registered in the
* driver core subsystem, this function takes a reference to @ubi->dev, because
* otherwise the release function ('dev_release()') would free whole @ubi
* object. The @ref argument is set to %1 in this case. The caller has to put
* this reference.
*
* This function returns zero in case of success and a negative error code in
* case of failure.
*/
static int uif_init(struct ubi_device *ubi, int *ref)
{
int i, err;
*ref = 0;
sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num);
err = ubi_cdev_add(ubi);
if (err) {
ubi_err("cannot add character device");
goto out_unreg;
}
for (i = 0; i < ubi->vtbl_slots; i++)
if (ubi->volumes[i]) {
err = ubi_add_volume(ubi, ubi->volumes[i]);
if (err) {
ubi_err("cannot add volume %d", i);
goto out_volumes;
}
}
return 0;
out_volumes:
kill_volumes(ubi);
devfs_remove(&ubi->cdev);
out_unreg:
ubi_err("cannot initialize UBI %s, error %d", ubi->ubi_name, err);
return err;
}
static void miiphy_remove(struct device_d *dev)
{
struct miiphy_device *mdev = dev->priv;
free(mdev->cdev.name);
devfs_remove(&mdev->cdev);
}
static void __exit dsp56k_cleanup_driver(void)
{
class_simple_device_remove(MKDEV(DSP56K_MAJOR, 0));
class_simple_destroy(dsp56k_class);
unregister_chrdev(DSP56K_MAJOR, "dsp56k");
devfs_remove("dsp56k");
}
/**
* usb_deregister_dev - deregister a USB device's dynamic minor.
* @intf: pointer to the usb_interface that is being deregistered
* @class_driver: pointer to the usb_class_driver for this device
*
* Used in conjunction with usb_register_dev(). This function is called
* when the USB driver is finished with the minor numbers gotten from a
* call to usb_register_dev() (usually when the device is disconnected
* from the system.)
*
* This function also cleans up the devfs file for the usb device, if devfs
* is enabled, and removes the usb class device from the sysfs tree.
*
* This should be called by all drivers that use the USB major number.
*/
void usb_deregister_dev(struct usb_interface *intf,
struct usb_class_driver *class_driver)
{
int minor_base = class_driver->minor_base;
char name[BUS_ID_SIZE];
#ifdef CONFIG_USB_DYNAMIC_MINORS
minor_base = 0;
#endif
if (intf->minor == -1)
return;
dbg ("removing %d minor", intf->minor);
spin_lock (&minor_lock);
usb_minors[intf->minor] = NULL;
spin_unlock (&minor_lock);
snprintf(name, BUS_ID_SIZE, class_driver->name, intf->minor - minor_base);
devfs_remove (name);
class_device_destroy(usb_class, MKDEV(USB_MAJOR, intf->minor));
intf->class_dev = NULL;
intf->minor = -1;
}
kern_return_t OsqueryStop(kmod_info_t *ki, void *d) {
dbg_printf("Kernel module stoping!\n");
lck_mtx_lock(osquery.mtx);
if (osquery.open_count > 0) {
lck_mtx_unlock(osquery.mtx);
return KERN_FAILURE;
}
if (osquery_cqueue_teardown(&osquery.cqueue)) {
lck_mtx_unlock(osquery.mtx);
return KERN_FAILURE;
}
devfs_remove(osquery.devfs);
osquery.devfs = NULL;
if (cdevsw_remove(osquery.major_number, &osquery_cdevsw) < 0) {
panic("osquery kext: Cannot remove osquery from cdevsw");
}
lck_mtx_unlock(osquery.mtx);
teardown_locks();
return KERN_SUCCESS;
}
kern_return_t OsqueryStop(kmod_info_t *ki, void *d) {
dbg_printf("Kernel module stopping!\n");
// Only stop if there are no connected daemons.
lck_mtx_lock(osquery.mtx);
if (osquery.open_count > 0) {
lck_mtx_unlock(osquery.mtx);
return KERN_FAILURE;
}
// Stop sharing the queue and remove queue locks.
// This will potentially block as heuristics are applied to make sure the
// queue is no longer is use.
if (osquery_cqueue_teardown(&osquery.cqueue)) {
lck_mtx_unlock(osquery.mtx);
return KERN_FAILURE;
}
// Remove the device node.
devfs_remove(osquery.devfs);
osquery.devfs = NULL;
// Tear down the device node data.
if (cdevsw_remove(osquery.major_number, &osquery_cdevsw) < 0) {
panic("osquery kext: Cannot remove osquery from cdevsw");
}
// Deallocate the IOCTL and kernel API locks.
lck_mtx_unlock(osquery.mtx);
teardown_locks();
return KERN_SUCCESS;
}
void
vnclear(struct vn_softc *vn, vfs_context_t ctx)
{
if (vn->sc_vp != NULL) {
/* release long-term reference */
(void)vn_close(vn->sc_vp, vn->sc_open_flags, ctx);
vn->sc_vp = NULL;
}
if (vn->sc_shadow_vp != NULL) {
/* release long-term reference */
(void)vn_close(vn->sc_shadow_vp, FREAD | FWRITE, ctx);
vn->sc_shadow_vp = NULL;
}
if (vn->sc_shadow_map != NULL) {
shadow_map_free(vn->sc_shadow_map);
vn->sc_shadow_map = NULL;
}
vn->sc_flags &= ~(VNF_INITED | VNF_READONLY);
if (vn->sc_cred) {
kauth_cred_unref(&vn->sc_cred);
}
vn->sc_size = 0;
vn->sc_fsize = 0;
if (vn->sc_cdev) {
devfs_remove(vn->sc_cdev);
vn->sc_cdev = NULL;
}
}
// Tries to free all resources and also passes through any errors
//
// args: the error arg will be overwritten with KERN_FAILURE in case of an error
// or returned unmodified in case everything went well.
// return: the given error argument or KERN_FAILURE if anything went wrong
static int pmem_cleanup(int error) {
if (pmem_zero_page) {
OSFree(pmem_zero_page, PAGE_SIZE, pmem_tag);
}
if (pte_mmap != NULL) {
pte_mmap_osx_delete(pte_mmap);
}
if (pmem_tag) {
OSMalloc_Tagfree(pmem_tag);
}
if (pmem_devpmemnode) {
devfs_remove(pmem_devpmemnode);
}
if (pmem_devmajor != -1) {
int devindex = 0;
devindex = cdevsw_remove(pmem_devmajor, &pmem_cdevsw);
if (devindex != pmem_devmajor) {
pmem_error("Failed to remove cdevsw, cdevsw_remove() returned %d,"
"should be %d", devindex, pmem_devmajor);
pmem_error("Kext will not be unloaded as an uio could result"
" in calling non-existent code");
error = KERN_FAILURE;
}
}
return error;
}
static void __devexit cpqarray_remove_one(int i)
{
int j;
char buff[4];
/* sendcmd will turn off interrupt, and send the flush...
* To write all data in the battery backed cache to disks
* no data returned, but don't want to send NULL to sendcmd */
if( sendcmd(FLUSH_CACHE, i, buff, 4, 0, 0, 0))
{
printk(KERN_WARNING "Unable to flush cache on controller %d\n",
i);
}
free_irq(hba[i]->intr, hba[i]);
iounmap(hba[i]->vaddr);
unregister_blkdev(COMPAQ_SMART2_MAJOR+i, hba[i]->devname);
del_timer(&hba[i]->timer);
remove_proc_entry(hba[i]->devname, proc_array);
pci_free_consistent(hba[i]->pci_dev,
NR_CMDS * sizeof(cmdlist_t), (hba[i]->cmd_pool),
hba[i]->cmd_pool_dhandle);
kfree(hba[i]->cmd_pool_bits);
for(j = 0; j < NWD; j++) {
if (ida_gendisk[i][j]->flags & GENHD_FL_UP)
del_gendisk(ida_gendisk[i][j]);
devfs_remove("ida/c%dd%d",i,j);
put_disk(ida_gendisk[i][j]);
}
blk_cleanup_queue(hba[i]->queue);
release_io_mem(hba[i]);
free_hba(i);
}
/*
* Module init/exit
*/
static int __init venus_ir_wo_init_module(void) {
int result;
/* MKDEV */
dev_venus_ir_wo = MKDEV(VENUS_IR_WO_MAJOR, VENUS_IR_WO_MINOR_RP);
/* Request Device Number */
result = register_chrdev_region(dev_venus_ir_wo, VENUS_IR_WO_DEVICE_NUM, "venus_ir_wo");
if (result < 0) {
printk(KERN_WARNING "venus_ir_wo: can't register device number.\n");
goto fail_alloc_dev;
}
venus_ir_wo_devs = platform_device_register_simple("VenusIR_W", -1, NULL, 0);
if (driver_register(&venus_ir_wo_driver) != 0)
goto fail_device_register;
/* create sysfs files */
device_create_file(&venus_ir_wo_devs->dev, &dev_attr_fakekey);
/* Char Device Registration */
venus_ir_wo_cdev = cdev_alloc();
if (venus_ir_wo_cdev == NULL) {
printk(KERN_ERR "venus_ir_wo: can't allocate cdev\n");
result = -ENOMEM;
goto fail_cdev_alloc;
}
venus_ir_wo_cdev->ops = &venus_ir_wo_fops;
if (cdev_add(venus_ir_wo_cdev, MKDEV(VENUS_IR_WO_MAJOR, VENUS_IR_WO_MINOR_RP), 1)) {
printk(KERN_ERR "venus_ir_wo: can't add character device\n");
result = -ENOMEM;
goto fail_cdev_add;
}
/* use devfs to create device file */
devfs_mk_cdev(MKDEV(VENUS_IR_WO_MAJOR, VENUS_IR_WO_MINOR_RP), S_IFCHR|S_IRUSR|S_IWUSR, VENUS_IR_WO_DEVICE_FILE);
/* rest of the init */
result = venus_ir_wo_init();
if (result)
goto fail_init;
printk(KERN_INFO "venus_ir_wo: driver loaded\n");
return 0; /* success */
fail_init:
devfs_remove(VENUS_IR_WO_DEVICE_FILE);
fail_cdev_add:
cdev_del(venus_ir_wo_cdev);
fail_cdev_alloc:
driver_unregister(&venus_ir_wo_driver);
device_remove_file(&venus_ir_wo_devs->dev, &dev_attr_fakekey);
fail_device_register:
if (!IS_ERR(venus_ir_wo_devs))
platform_device_unregister(venus_ir_wo_devs);
unregister_chrdev_region(dev_venus_ir_wo, VENUS_IR_WO_DEVICE_NUM);
fail_alloc_dev:
return result;
}
static void deinit_vfc_device(struct vfc_dev *dev)
{
if(dev == NULL)
return;
devfs_remove("vfc/%d", dev->instance);
sbus_iounmap((unsigned long)dev->regs, sizeof(struct vfc_regs));
kfree(dev);
}
static void jtag_remove(struct device_d *pdev)
{
struct jtag_info *info = (struct jtag_info *) pdev->priv;
devfs_remove(&info->cdev);
pdev->priv = NULL;
free(info);
dev_notice(pdev, "Device removed\n");
}
void ubi_cdev_remove(struct ubi_device *ubi)
{
struct cdev *cdev = &ubi->cdev;
ubi_msg(ubi, "removing %s", cdev->name);
devfs_remove(cdev);
kfree(cdev->name);
}
/*------------------------------------------------------------------
* Func : mcp_module_exit
*
* Desc : mcp module exit function
*
* Parm : N/A
*
* Retn : N/A
*------------------------------------------------------------------*/
static void __exit mcp_module_exit(void)
{
platform_device_unregister(mcp_device);
cdev_del(&mcp_dev);
devfs_remove(MCP_DEV_FILE_NAME);
unregister_chrdev_region(devno, 1);
mcp_uninit();
}
static void __exit mbd_cleanup(void)
{
devfs_remove("mambobd");
if (unregister_blkdev(MAJOR_NR, "mbd") != 0)
printk("mbd: cleanup_module failed\n");
else
printk("mbd: module cleaned up.\n");
}
void ubi_cdev_remove(struct ubi_device *ubi)
{
struct cdev *cdev = &ubi->cdev;
printf("removing %s\n", cdev->name);
devfs_remove(cdev);
kfree(cdev->name);
}
/**
* Unload the module.
*/
static void __exit VBoxDrvLinuxUnload(void)
{
int rc;
Log(("VBoxDrvLinuxUnload\n"));
NOREF(rc);
#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
platform_device_unregister(&gPlatformDevice);
platform_driver_unregister(&gPlatformDriver);
#endif
/*
* I Don't think it's possible to unload a driver which processes have
* opened, at least we'll blindly assume that here.
*/
#ifdef CONFIG_VBOXDRV_AS_MISC
rc = misc_deregister(&gMiscDeviceUsr);
if (rc < 0)
{
Log(("misc_deregister failed with rc=%#x on vboxdrvu\n", rc));
}
rc = misc_deregister(&gMiscDeviceSys);
if (rc < 0)
{
Log(("misc_deregister failed with rc=%#x on vboxdrv\n", rc));
}
#else /* !CONFIG_VBOXDRV_AS_MISC */
# ifdef CONFIG_DEVFS_FS
/*
* Unregister a device entry
*/
devfs_remove(DEVICE_NAME_USR);
devfs_remove(DEVICE_NAME_SYS);
# endif /* devfs */
unregister_chrdev(g_iModuleMajorUsr, DEVICE_NAME_USR);
unregister_chrdev(g_iModuleMajorSys, DEVICE_NAME_SYS);
#endif /* !CONFIG_VBOXDRV_AS_MISC */
/*
* Destroy GIP, delete the device extension and terminate IPRT.
*/
supdrvDeleteDevExt(&g_DevExt);
RTR0TermForced();
}
static int del_mtdoob_device(struct mtd_info *mtd, void **priv)
{
struct mtdoob *mtdoob;
mtdoob = *priv;
devfs_remove(&mtdoob->cdev);
free(mtdoob);
return 0;
}
static int del_mtdraw_device(struct mtd_info *mtd, void **priv)
{
struct mtdraw *mtdraw;
mtdraw = *priv;
devfs_remove(&mtdraw->cdev);
free(mtdraw);
return 0;
}
