static int tc05(void) { int major, pass = 16; unsigned int i, test_major[2] = {512, UINT_MAX}; prk_info("Test Case 5: register_blkdev() with major=%u/%u\n", test_major[0], test_major[1]); for (i = 0; i < sizeof(test_major) / sizeof(unsigned int); i++) { major = register_blkdev(test_major[i], BLK_DEV_NAME); prk_debug("major = %i\n", major); if (major == 0) { unregister_blkdev(test_major[i], BLK_DEV_NAME); #ifdef BLKDEV_MAJOR_MAX pass = 0; #endif } else { prk_debug("register_blkdev() with major %u got error %i\n", test_major[i], major); #ifndef BLKDEV_MAJOR_MAX pass = 0; #endif } } prk_info("Test Case Result: %s\n", result_str(pass)); return pass; }
static int tc04(void) { int major, pass = 8; unsigned int i, test_major[2] = {256, 511}; prk_info("Test Case 4: register_blkdev() with major=%u/%u\n", test_major[0], test_major[1]); for (i = 0; i < sizeof(test_major) / sizeof(unsigned int); i++) { major = register_blkdev(test_major[i], BLK_DEV_NAME); prk_debug("major = %i\n", major); if (major == 0) { unregister_blkdev(test_major[i], BLK_DEV_NAME); } else if (major == -EBUSY) { prk_debug("device was busy, register_blkdev() with major %u skipped\n", test_major[i]); } else { pass = 0; prk_debug("register_blkdev() with major %u got error %i\n", test_major[i], major); } } prk_info("Test Case Result: %s\n", result_str(pass)); return pass; }
static void __exit ace_exit(void) { pr_debug("Unregistering Xilinx SystemACE driver\n"); platform_driver_unregister(&ace_platform_driver); ace_of_unregister(); unregister_blkdev(ace_major, "xsysace"); }
static void __exit ramblock_exit(void) { unregister_blkdev(major, "ramblock"); del_gendisk(ramblock_disk); put_disk(ramblock_disk); blk_cleanup_queue(ramblock_queue); }
static void osprd_exit(void) { int i; for (i = 0; i < NOSPRD; i++) cleanup_device(&osprds[i]); unregister_blkdev(OSPRD_MAJOR, "osprd"); }
static int __init sbull_init(void) { int i; printk(KERN_EMERG "sbull: sbull_init\n"); /* * Get registered. */ sbull_major = register_blkdev(sbull_major, "sbull"); if (sbull_major <= 0) { printk(KERN_WARNING "sbull: unable to get major number\n"); return -EBUSY; } /* * Allocate the device array, and initialize each one. */ Devices = kmalloc(ndevices*sizeof (struct sbull_dev), GFP_KERNEL); if (Devices == NULL) goto out_unregister; for (i = 0; i < ndevices; i++) setup_device(Devices + i, i); return 0; out_unregister: unregister_blkdev(sbull_major, "sbd"); return -ENOMEM; }
/* --------------------------------------------------------------------- * Module init/exit routines */ static int __init ace_init(void) { int rc; ace_major = register_blkdev(ace_major, "xsysace"); if (ace_major <= 0) { rc = -ENOMEM; goto err_blk; } rc = ace_of_register(); if (rc) goto err_of; pr_debug("xsysace: registering platform binding\n"); rc = platform_driver_register(&ace_platform_driver); if (rc) goto err_plat; pr_info("Xilinx SystemACE device driver, major=%i\n", ace_major); return 0; err_plat: ace_of_unregister(); err_of: unregister_blkdev(ace_major, "xsysace"); err_blk: printk(KERN_ERR "xsysace: registration failed; err=%i\n", rc); return rc; }
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]); put_disk(ida_gendisk[i][j]); } blk_cleanup_queue(hba[i]->queue); release_io_mem(hba[i]); free_hba(i); }
static void memcon_exit(void) { pci_unregister_driver(&pblaze_pcie_driver); unregister_blkdev(raid_drv.major, "memcon"); pblaze_virt_bus_unregister(); kmem_cache_destroy(raid_drv.ioreq_slab); }
static int __init ndas_init(void) { int retval = 0; struct ndas_dev *dev; func(); retval = register_blkdev(0, "myndas"); if (retval <= 0) { printk(KERN_ERR "ndas: failed to register device\n"); return retval; } else { major_number = retval; printk(KERN_INFO "ndas: register device major number %d\n", major_number); } /* init block device */ dev = kmalloc(sizeof(struct ndas_dev), GFP_KERNEL); if (dev == NULL) { printk(KERN_ERR "ndas: failed to allocate memory for device\n"); goto err1; } memset(dev, sizeof(struct ndas_dev), 0); spin_lock_init(&dev->lock); Device = dev; /* init queue */ dev->queue = blk_init_queue(ndas_request, &dev->lock); if (dev->queue == NULL) { printk(KERN_ERR "ndas: failed to allocate memory for queue\n"); goto err2; } blk_queue_logical_block_size(dev->queue, HARDSECT_SIZE); dev->queue->queuedata = dev; /* gendisk structure */ dev->gd = alloc_disk(NDAS_MINORS); if (dev->gd == NULL) { printk(KERN_ERR "ndas: failed to allocate memory for gendisk\n"); goto err3; } dev->gd->major = major_number; dev->gd->first_minor = 0; dev->gd->fops = &blk_ops; dev->gd->queue = dev->queue; dev->gd->private_data = dev; set_capacity(dev->gd, NSECTOR * (HARDSECT_SIZE / KERNEL_SECTOR_SIZE)); snprintf(dev->gd->disk_name, 6, "myndas"); add_disk(dev->gd); return 0; err3: blk_cleanup_queue(dev->queue); err2: kfree(dev); err1: Device = NULL; unregister_blkdev(major_number, "ndas"); return -ENOMEM; }
static void __exit sb_exit(void) { /* Free kernel memory */ put_disk(sbd->gd); del_gendisk(sbd->gd); kfree(sbd); unregister_blkdev(MAJOR_NODE, DEV_NAME); release_region(REG_BASE, REG_LEN); }
static int tc03(void) { int major, major2, major3; int pass = 4; prk_info("Test Case 3: register_blkdev() with major != 0\n"); /* autosearch for a free major number */ major = register_blkdev(0, BLK_DEV_NAME); prk_debug("major = %i\n", major); if (major > 0) { unregister_blkdev(major, BLK_DEV_NAME); /* expected to return 0 */ major2 = register_blkdev(major, BLK_DEV_NAME); /* this call has to fail with EBUSY return value */ major3 = register_blkdev(major, BLK_DEV_NAME); if (major2 == 0) { unregister_blkdev(major, BLK_DEV_NAME); } else { pass = 0; prk_debug("1st call to register_blkdev() with major=%i " "failed with error %i\n", major, major2); } if (major3 == 0) { unregister_blkdev(major, BLK_DEV_NAME); pass = 0; } else { if (major3 != -EBUSY) pass = 0; prk_debug("2nd call to register_blkdev() with major=%i " "failed with error %i\n", major, major3); } } else { pass = 0; prk_debug("register_blkdev() failed with error %i\n", major); } prk_info("Test Case Result: %s\n", result_str(pass)); return pass; }
static void __exit looper_exit(void) { del_gendisk(Device.gd); put_disk(Device.gd); unregister_blkdev(major_num, "looper"); blk_cleanup_queue(Queue); vfree(Device.data); }
static void __exit simpleblockexit(void) { del_gendisk(Device.gd); put_disk(Device.gd); unregister_blkdev(major_num, "sbd"); blk_cleanup_queue(Queue); vfree(Device.data); }
static void __exit mini2440_ramdisk_exit(void) { del_gendisk(mini2440_ramdisk_devp->gdisk); put_disk(mini2440_ramdisk_devp->gdisk); kfree(mini2440_ramdisk_devp->ramdisk_buffer); blk_cleanup_queue(mini2440_ramdisk_devp->queue); kfree(mini2440_ramdisk_devp); unregister_blkdev(mini2440_ramdisk_major, "mini2440_ramdisk"); }
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 zvol_fini(void) { zvol_remove_minors(NULL); blk_unregister_region(MKDEV(zvol_major, 0), 1UL << MINORBITS); unregister_blkdev(zvol_major, ZVOL_DRIVER); mutex_destroy(&zvol_state_lock); list_destroy(&zvol_state_list); }
void sbull_cleanup(void) { int i; /* * Before anything else, get rid of the timer functions. Set the "usage" * flag on each device as well, under lock, so that if the timer fires up * just before we delete it, it will either complete or abort. Otherwise * we have nasty race conditions to worry about. */ for (i = 0; i < sbull_devs; i++) { Sbull_Dev *dev = sbull_devices + i; del_timer(&dev->timer); spin_lock(&dev->lock); dev->usage++; spin_unlock(&dev->lock); } #ifdef DO_RAW_INTERFACE sbullr_release(); #endif /* flush it all and reset all the data structures */ for (i=0; i<sbull_devs; i++) fsync_dev(MKDEV(sbull_major, i)); /* flush the devices */ unregister_blkdev(major, "sbull"); /* * Fix up the request queue(s) */ #ifdef SBULL_MULTIQUEUE for (i = 0; i < sbull_devs; i++) blk_cleanup_queue(&sbull_devices[i].queue); blk_dev[major].queue = NULL; #else blk_cleanup_queue(BLK_DEFAULT_QUEUE(major)); #endif /* Clean up the global arrays */ read_ahead[major] = 0; kfree(blk_size[major]); blk_size[major] = NULL; kfree(blksize_size[major]); blksize_size[major] = NULL; kfree(hardsect_size[major]); hardsect_size[major] = NULL; /* FIXME: max_readahead and max_sectors */ /* finally, the usual cleanup */ for (i=0; i < sbull_devs; i++) { if (sbull_devices[i].data) vfree(sbull_devices[i].data); } kfree(sbull_devices); }
static void __exit sbd_exit(void) { crypto_free_cipher(crypt); del_gendisk(Device.gd); put_disk(Device.gd); unregister_blkdev(major_num, "sbd"); blk_cleanup_queue(Queue); vfree(Device.data); }
/* * Cleanup and deregister the device on rmmod */ static void __exit vbd_exit(void) { remove_proc_entry(MODULE_NAME, NULL); del_gendisk(device.gd); put_disk(device.gd); unregister_blkdev(major_num, MODULE_NAME); blk_cleanup_queue(vbd_queue); vfree(device.data); }
static void ramblk_exit(void) { unregister_blkdev(major,"ramblk");//注销设备驱动 blk_cleanup_queue(ramblk_request_queue);//清除队列 del_gendisk(ramblk_disk); put_disk(ramblk_disk); vfree(ramblk_buf);//释放申请的内存 printk("ramblk_exit.\n"); }
static void imgrement_exit(void) { struct imgrement_device *dev = imgrement_device; LOG("Removing imgrement, rollback every changes"); if (dev == NULL) return; if (dev->base_queue != NULL && dev->orig_req_fn != NULL) dev->base_queue->make_request_fn = dev->orig_req_fn; if (dev->major) unregister_blkdev(dev->major, DRIVER_NAME); kfree(dev); }
static void local_exit(void) { kmem_cache_destroy(_tio_cache); kmem_cache_destroy(_io_cache); unregister_blkdev(_major, _name); _major = 0; DMINFO("cleaned up"); }
void cleanup_module(void) { if ((unregister_blkdev(MAJOR_NR, "mcd") == -EINVAL)) { printk("What's that: can't unregister mcd\n"); return; } release_region(mcd_port,4); free_irq(mcd_irq, NULL); printk(KERN_INFO "mcd module released.\n"); }
static void __exit my_exit(void) { del_gendisk(my_gd); put_disk(my_gd); unregister_blkdev(mybdrv_ma_no, MY_DEVICE_NAME); printk(KERN_INFO "module successfully unloaded, Major No. = %d\n", mybdrv_ma_no); blk_cleanup_queue(my_request_queue); vfree(ramdisk); }
static void __exit ldm_exit(void) { printk(KERN_ALERT "%s\n", __FUNCTION__); put_disk(ldm.disk); blk_cleanup_queue(ldm.disk->queue); vfree(ldm.addr); unregister_blkdev(ldm.disk->major, DEVNAME); del_gendisk(ldm.disk); }
static int memcon_init(void) { int ret; memset(&raid_drv, 0, sizeof(raid_drv)); raid_drv.driver_mem_size = 53872u; #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20) raid_drv.ioreq_slab = kmem_cache_create("io_request", sizeof(struct io_request), 0, SLAB_HWCACHE_ALIGN, NULL, NULL); #else raid_drv.ioreq_slab = kmem_cache_create("io_request", sizeof(struct io_request), 0, SLAB_HWCACHE_ALIGN, NULL); #endif if (!raid_drv.ioreq_slab) { DPRINTK(ERR, "memcon init: ioreq slab init failed\n"); ret = -ENOMEM; goto failed_create_ioreq_slab; } ret = pblaze_virt_bus_register(); if (ret) { DPRINTK(ERR, "memcon: unable to register bus\n"); goto failed_register_virbus; } raid_drv.major = register_blkdev(raid_drv.major, "memcon"); if (unlikely(raid_drv.major < 0)) { DPRINTK(ERR, "memcon: unable to get major number\n"); ret = raid_drv.major; goto failed_register_blkdev; } init_MUTEX(&raid_drv.sem); INIT_LIST_HEAD(&raid_list); spin_lock_init(&raid_list_lock); ret = pci_register_driver(&pblaze_pcie_driver); if (ret < 0) { DPRINTK(ERR, "pci_register_driver failed\n"); goto failed_register_driver; } DPRINTK(DEBUG, "memcon init success\n"); return 0; failed_register_driver: unregister_blkdev(raid_drv.major, "memcon"); failed_register_blkdev: pblaze_virt_bus_unregister(); failed_register_virbus: kmem_cache_destroy(raid_drv.ioreq_slab); failed_create_ioreq_slab: return ret; }
/** * @brief SD driver initial function. * @return SUCCESS/ERROR_ID. */ static int __init gp_sdcard_init(void) { int i; /* ----- Get registered. ----- */ sd_major = register_blkdev(sd_major, "sdcard"); if (sd_major <= 0) { DERROR(KERN_WARNING "SD card : unable to get major number\n"); return -EBUSY; } /* ----- Allocate the device array, and initialize each one. ----- */ sd_info = kmalloc(SD_NUM*sizeof (gpSDInfo_t), GFP_KERNEL); if (sd_info == NULL) goto out_unregister; /* ----- Initial SD information ----- */ for(i=0; i<SD_NUM; i++) { gpSDInfo_t *sd = &sd_info[i]; /* ----- Clear memory ----- */ memset (sd, 0, sizeof (gpSDInfo_t)); sd->device_id = i; /* ----- Initial spinlock ----- */ spin_lock_init(&sd->lock); spin_lock_init(&sd->hal_lock); /* ----- Initial work queue ----- */ INIT_WORK(&sd->init, gp_sdcard_work_init); INIT_WORK(&sd->uninit, gp_sdcard_work_uninit); if(i==0) { /* ----- request IO function ----- */ sd->sd_func = gp_board_get_config("sd0",gp_board_sd_t); /* ----- Initial dma module ----- */ sd->dma_param.module = SD0; } else { /* ----- request IO function ----- */ sd->sd_func = gp_board_get_config("sd1",gp_board_sd_t); /* ----- Initial dma module ----- */ sd->dma_param.module = SD1; } /* ----- Init timer ----- */ init_timer(&sd->timer); sd->timer.data = (unsigned long) sd; sd->timer.function = gp_sdcard_timer_fn; sd->timer.expires = jiffies + SD_CD_POLL; add_timer(&sd->timer); } gp_sdio_init(); return 0; out_unregister: unregister_blkdev(sd_major, "sdcard"); return -ENOMEM; }
static void aoe_exit(void) { discover_timer(TKILL); aoenet_exit(); unregister_blkdev(AOE_MAJOR, DEVICE_NAME); aoechr_exit(); aoedev_exit(); aoeblk_exit(); /* free cache after de-allocating bufs */ }
static void aoe_exit(void) { discover_timer(TKILL); aoenet_exit(); unregister_blkdev(AOE_MAJOR, DEVICE_NAME); aoechr_exit(); aoedev_exit(); aoeblk_exit(); }