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 */ }