static void __exit stheno_module_exit( void )
{
del_gendisk( stheno_gd );
put_disk( stheno_gd );
blk_cleanup_queue( stheno_queue );
unregister_blkdev( stheno_major, MODNAME );
printk( KERN_INFO "stheno is removed\n" );
}
/*
* Cleanup then free a zvol_state_t which was created by zvol_alloc().
*/
static void
zvol_free(zvol_state_t *zv)
{
avl_destroy(&zv->zv_znode.z_range_avl);
mutex_destroy(&zv->zv_znode.z_range_lock);
del_gendisk(zv->zv_disk);
blk_cleanup_queue(zv->zv_queue);
put_disk(zv->zv_disk);
kmem_free(zv, sizeof (zvol_state_t));
}
static void tbio_exit(void)
{
if(Device.bdev) {
invalidate_bdev(Device.bdev,1);
bdput(Device.bdev);
}
del_gendisk(Device.gd);
put_disk(Device.gd);
unregister_blkdev(TBIO_MAJOR , "tbio");
vfree(Device.data);
}
static void tc20(void)
{
struct gendisk *gd_ptr;
gd_ptr = alloc_disk(1);
if (!gd_ptr) {
return;
}
printk(KERN_DEBUG "gd_ptr after alloc=%p\n", gd_ptr);
del_gendisk(gd_ptr);
}
static void null_del_dev(struct nullb *nullb)
{
list_del_init(&nullb->list);
del_gendisk(nullb->disk);
if (queue_mode == NULL_Q_MQ)
blk_mq_free_queue(nullb->q);
else
blk_cleanup_queue(nullb->q);
put_disk(nullb->disk);
kfree(nullb);
}
static void cleanup_device(osprd_info_t *d)
{
wake_up_all(&d->blockq);
if (d->gd) {
del_gendisk(d->gd);
put_disk(d->gd);
}
if (d->queue)
blk_cleanup_queue(d->queue);
if (d->data)
vfree(d->data);
}
static void
aoedev_freedev(struct aoedev *d)
{
if (d->gd) {
aoedisk_rm_sysfs(d);
del_gendisk(d->gd);
put_disk(d->gd);
}
kfree(d->frames);
if (d->bufpool)
mempool_destroy(d->bufpool);
kfree(d);
}
static void __exit sbd_exit(void)
{
del_gendisk(Device.gd);
put_disk(Device.gd);
unregister_blkdev(major_num, "sbd");
blk_cleanup_queue(Queue);
crypto_free_cipher(tfm);
device_remove_file(&rd_root_dev, &dev_attr_key);
device_unregister(&rd_root_dev);
vfree(Device.data);
}
static void ramblock_exit(void)
{
unregister_blkdev(major, "ramblock");
del_gendisk(ramblock_gendisk);
/* put_disk(ramblock_gendisk);
* 视频里有这一句话，我这里注释掉貌似也没什么问题
* 应该是需要的，要把计数器减去1
*/
blk_cleanup_queue(ramblock_request_queue);
kfree(ramblock_buf);
}
void ramhd_exit(void) {
int i;
for (i = 0; i < RAMHD_MAX_DEVICE; i++) {
del_gendisk(rdev[i]->gd);
put_disk(rdev[i]->gd);
blk_cleanup_queue(rdev[i]->queue);
}
unregister_blkdev(ramhd_major, RAMHD_NAME);
clean_ramdev();
ramhd_space_clean();
}
static void ide_gd_remove(ide_drive_t *drive)
{
struct ide_disk_obj *idkp = drive->driver_data;
struct gendisk *g = idkp->disk;
ide_proc_unregister_driver(drive, idkp->driver);
del_gendisk(g);
drive->disk_ops->flush(drive);
ide_disk_put(idkp);
}
LOCAL void slot_disable(int slot)
{
struct ndas_slot* sd = NDAS_GET_SLOT_DEV(slot);
dbgl_blk(2, "ing slot=%d",slot);
if ( sd == NULL ) {
dbgl_blk(0, "ndas: fix me at slot_disable!!");
goto out;
}
down(&sd->mutex);
if ( !sd->enabled ) {
dbgl_blk(1, "ed slot=%d is already disabled",slot);
up(&sd->mutex);
goto out;
}
#if LINUX_VERSION_25_ABOVE
del_gendisk(sd->disk);
put_disk(sd->disk);
sd->disk = NULL;
blk_cleanup_queue(sd->queue);
sd->queue = NULL;
#else
ndas_ops_set_blk_size(slot, 0, 0, 0, 0);
ndas_ops_invalidate_slot(slot);
#endif
#ifdef NDAS_DEVFS
// devfs_unregister(sd->devfs_handle);
#endif
sd->enabled = 0;
up(&sd->mutex);
module_put(THIS_MODULE);
MOD_DEC_USE_COUNT;
if ( sd ) {
#if LINUX_VERSION_25_ABOVE
printk("ndas: /dev/%s is disabled\n", sd->devname);
#else
#ifdef NDAS_DEVFS
printk("ndas: /dev/nd/disc%d is disabled\n", slot - NDAS_FIRST_SLOT_NR);
#else
printk("ndas: /dev/nd%c is disabled\n", slot + 'a' - NDAS_FIRST_SLOT_NR);
#endif
#endif
}
else
printk("ndas: slot %d is disabled\n", slot);
out:
dbgl_blk(3, "ed");
}
void cleanup_module(void)
{
printk(KERN_ALERT "Exiting module and cleaning up \n");
pm_unregister(ltp_pm_dev);
put_disk(gd_ptr);
del_gendisk(gd_ptr);
unregister_blkdev(ltp_fs_major, LTP_FS_DEV_NAME);
}
static void ide_gd_remove(ide_drive_t *drive)
{
struct ide_disk_obj *idkp = drive->driver_data;
struct gendisk *g = idkp->disk;
ide_proc_unregister_driver(drive, idkp->driver);
device_del(&idkp->dev);
del_gendisk(g);
drive->disk_ops->flush(drive);
mutex_lock(&ide_disk_ref_mutex);
put_device(&idkp->dev);
mutex_unlock(&ide_disk_ref_mutex);
}
static void pt_exit(void)
{
if (passthrough->gd) {
del_gendisk(passthrough->gd);
put_disk(passthrough->gd);
}
if (passthrough->queue)
blk_cleanup_queue(passthrough->queue);
blkdev_put(passthrough->target_dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
unregister_blkdev(passthrough->major, "passthrough");
kfree(passthrough);
}
/**
* axon_ram_remove - remove() method for platform driver
* @device: see of_platform_driver method
*/
static int
axon_ram_remove(struct platform_device *device)
{
struct axon_ram_bank *bank = device->dev.platform_data;
BUG_ON(!bank || !bank->disk);
device_remove_file(&device->dev, &dev_attr_ecc);
free_irq(bank->irq_id, device);
del_gendisk(bank->disk);
iounmap((void __iomem *) bank->io_addr);
kfree(bank);
return 0;
}
static void null_del_dev(struct nullb *nullb)
{
list_del_init(&nullb->list);
if (use_lightnvm)
null_nvm_unregister(nullb);
else
del_gendisk(nullb->disk);
blk_cleanup_queue(nullb->q);
if (queue_mode == NULL_Q_MQ)
blk_mq_free_tag_set(&nullb->tag_set);
if (!use_lightnvm)
put_disk(nullb->disk);
cleanup_queues(nullb);
kfree(nullb);
}
static void free_dev(struct mapped_device *md)
{
unsigned int minor = md->disk->first_minor;
if (md->suspended_bdev) {
thaw_bdev(md->suspended_bdev, NULL);
bdput(md->suspended_bdev);
}
mempool_destroy(md->tio_pool);
mempool_destroy(md->io_pool);
del_gendisk(md->disk);
free_minor(minor);
put_disk(md->disk);
blk_put_queue(md->queue);
kfree(md);
}
static void __exit stackbd_exit(void)
{
printk("stackbd: exit\n");
if (stackbd.is_active)
{
kthread_stop(stackbd.thread);
blkdev_put(stackbd.bdev_raw, STACKBD_BDEV_MODE);
bdput(stackbd. bdev_raw);
}
del_gendisk(stackbd.gd);
put_disk(stackbd.gd);
unregister_blkdev(major_num, STACKBD_NAME);
blk_cleanup_queue(stackbd.queue);
}
static void cleanup_device(osprd_info_t *d)
{
wake_up_all(&d->blockq);
if (d->gd) {
del_gendisk(d->gd);
put_disk(d->gd);
}
if (d->queue)
blk_cleanup_queue(d->queue);
if (d->data)
vfree(d->data);
linked_list_free(&d->read_locking_pids);
linked_list_free(&d->invalid_tickets);
d->passwd_hash = 0;
}
static void __exit sbd_exit(void)
{
if (clientsocket)
sock_release(clientsocket);
del_gendisk(Device.gd);
put_disk(Device.gd);
unregister_blkdev(major_num, "sbd");
blk_cleanup_queue(Queue);
vfree(Device.data);
printk("EXIT MODULE\n");
}
/*
* Cleanup then free a zvol_state_t which was created by zvol_alloc().
*/
static void
zvol_free(zvol_state_t *zv)
{
ASSERT(MUTEX_HELD(&zvol_state_lock));
ASSERT(zv->zv_open_count == 0);
zfs_rlock_destroy(&zv->zv_range_lock);
zv->zv_disk->private_data = NULL;
del_gendisk(zv->zv_disk);
blk_cleanup_queue(zv->zv_queue);
put_disk(zv->zv_disk);
kmem_free(zv, sizeof (zvol_state_t));
}
static void __devexit ace_teardown(struct ace_device *ace)
{
if (ace->gd) {
del_gendisk(ace->gd);
put_disk(ace->gd);
}
if (ace->queue)
blk_cleanup_queue(ace->queue);
tasklet_kill(&ace->fsm_tasklet);
if (ace->irq != NO_IRQ)
free_irq(ace->irq, ace);
iounmap(ace->baseaddr);
}
void __exit mcd_exit(void)
{
del_gendisk(mcd_gendisk);
put_disk(mcd_gendisk);
if (unregister_cdrom(&mcd_info)) {
printk(KERN_WARNING "Can't unregister cdrom mcd\n");
return;
}
free_irq(mcd_irq, NULL);
release_region(mcd_port, 4);
if (unregister_blkdev(MAJOR_NR, "mcd")) {
printk(KERN_WARNING "Can't unregister major mcd\n");
return;
}
blk_cleanup_queue(mcd_queue);
del_timer_sync(&mcd_timer);
}
static void cleanup_device(osprd_info_t *d)
{
wake_up_all(&d->blockq);
if (d->gd) {
del_gendisk(d->gd);
put_disk(d->gd);
}
if (d->queue)
blk_cleanup_queue(d->queue);
if (d->data)
vfree(d->data);
list_free_all(d->lock_holder_l);
list_free_all(d->lock_waiter_l);
d->lock_holder_l = NULL;
d->lock_waiter_l = NULL;
}
static void test_exit_module(void)
{
int rc;
pm_unregister(ltp_pm_dev);
put_disk(gd_ptr);
del_gendisk(gd_ptr);
rc = unregister_blkdev(INCLUDEMAJOR, DEVICE_NAME);
if (rc < 0) {
printk("unregister failed %d\n", rc);
} else {
printk("unregister success\n");
}
}
static void __devexit dm3730logic_cf_teardown(struct cf_device *cf)
{
DPRINTK(DEBUG_CF_ENTRY, "dm3730logic_cf_teardown(%p)\n", cf);
if (cf->gd) {
del_gendisk(cf->gd);
put_disk(cf->gd);
cf->gd = NULL;
}
if (cf->queue)
blk_cleanup_queue(cf->queue);
if (cf->irq != NO_IRQ)
free_irq(cf->irq, cf);
iounmap(cf->baseaddr);
}
static void
aoedev_freedev(struct aoedev *d)
{
struct aoetgt **t, **e;
if (d->gd) {
aoedisk_rm_sysfs(d);
del_gendisk(d->gd);
put_disk(d->gd);
}
t = d->targets;
e = t + NTARGETS;
for (; t < e && *t; t++)
freetgt(d, *t);
if (d->bufpool)
mempool_destroy(d->bufpool);
skbpoolfree(d);
kfree(d);
}
static void mmc_blk_remove(struct mmc_card *card)
{
struct mmc_blk_data *md = mmc_get_drvdata(card);
if (md) {
int devidx;
/* Stop new requests from getting into the queue */
del_gendisk(md->disk);
/* Then flush out any already in there */
mmc_cleanup_queue(&md->queue);
devidx = md->disk->first_minor >> MMC_SHIFT;
__clear_bit(devidx, dev_use);
mmc_blk_put(md);
}
mmc_set_drvdata(card, NULL);
}
static int xsysace_remove(struct device *dev)
{
if (!dev)
return -EINVAL;
proc_cleanup();
if (old_restart)
ppc_md.restart = old_restart;
unregister_blkdev(xsa_major, MAJOR_NAME);
del_gendisk(xsa_gendisk);
blk_cleanup_queue(xsysace_queue);
XSysAce_DisableInterrupt(&SysAce);
free_irq(xsa_irq, NULL);
iounmap((void *)(SysAce.BaseAddress));
release_mem_region(xsa_phys_addr, xsa_remap_size);
return 0; /* success */
}
