static int __init mbd_init(void) { int err = -ENOMEM; int i; for (i = 0; i < MAX_MBD; i++) { struct gendisk *disk = alloc_disk(1); if (!disk) goto out; mbd_dev[i].disk = disk; /* * The new linux 2.5 block layer implementation requires * every gendisk to have its very own request_queue struct. * These structs are big so we dynamically allocate them. */ disk->queue = blk_init_queue(do_mbd_request, &mbd_lock); if (!disk->queue) { put_disk(disk); goto out; } } if (register_blkdev(MAJOR_NR, "mbd")) { err = -EIO; goto out; } #ifdef MODULE printk("mambo bogus disk: registered device at major %d\n", MAJOR_NR); #else printk("mambo bogus disk: compiled in with kernel\n"); #endif devfs_mk_dir("mambobd"); for (i = 0; i < MAX_MBD; i++) { /* load defaults */ struct gendisk *disk = mbd_dev[i].disk; mbd_dev[i].initialized = 0; mbd_dev[i].refcnt = 0; mbd_dev[i].flags = 0; disk->major = MAJOR_NR; disk->first_minor = i; disk->fops = &mbd_fops; disk->private_data = &mbd_dev[i]; sprintf(disk->disk_name, "mambobd%d", i); sprintf(disk->devfs_name, "mambobd%d", i); set_capacity(disk, 0x7ffffc00ULL << 1); /* 2 TB */ add_disk(disk); } return 0; out: while (i--) { if (mbd_dev[i].disk->queue) blk_cleanup_queue(mbd_dev[i].disk->queue); put_disk(mbd_dev[i].disk); } return -EIO; }
void prep_prelaunch_bootrootlv (const char *filename, prep_data *data) { if (vg_lv_parse (data->params[0], NULL, NULL) == -1) prep_error (data, filename, _("incorrect format for LV name, use '/dev/VG/LV'")); if (alloc_disk (filename, data->params[3], 0, 1) == -1) prep_error (data, filename, _("failed to allocate disk")); }
/** * add_last_partition : add card last partition as a full device, refer to * board-****.c inand_partition_info[] last partition * @card: inand_card_lp * @size: set last partition capacity */ int add_last_partition(struct memory_card* card, uint64_t offset ,uint64_t size) { struct card_blk_data *card_data; int ret; card_data = kmalloc(sizeof(struct card_blk_data), GFP_KERNEL); if (!card_data) { ret = -ENOMEM; return ret; } memset(card_data, 0, sizeof(struct card_blk_data)); if(card->state & CARD_STATE_READONLY) card_data->read_only = 1; card_data->block_bits = 9; card_data->disk = alloc_disk(1 << CARD_SHIFT); if (card_data->disk == NULL) { ret = -ENOMEM; kfree(card_data); return ret; } spin_lock_init(&card_data->lock); card_data->usage = 1; ret = card_init_queue(&card_data->queue, card, &card_data->lock); if (ret) { put_disk(card_data->disk); return ret; } card->part_offset=offset; card_data->queue.prep_fn = card_blk_prep_rq; card_data->queue.issue_fn = card_blk_issue_rq; card_data->queue.data = card_data; card_data->disk->major = INAND_LAST_PART_MAJOR; card_data->disk->minors = 1 << CARD_SHIFT; card_data->disk->first_minor = 0; card_data->disk->fops = &card_ops; card_data->disk->private_data = card_data; card_data->disk->queue = card_data->queue.queue; card_data->disk->driverfs_dev = &card->dev; sprintf(card_data->disk->disk_name, "cardblk%s", card->name); blk_queue_logical_block_size(card_data->queue.queue, 1 << card_data->block_bits); set_capacity(card_data->disk, size); card_set_drvdata(card, card_data); add_disk(card_data->disk); return 0; }
/* alloc_disk and add_disk can sleep */ void aoeblk_gdalloc(void *vp) { struct aoedev *d = vp; struct gendisk *gd; ulong flags; gd = alloc_disk(AOE_PARTITIONS); if (gd == NULL) { printk(KERN_ERR "aoe: cannot allocate disk structure for %ld.%d\n", d->aoemajor, d->aoeminor); goto err; } d->bufpool = mempool_create_slab_pool(MIN_BUFS, buf_pool_cache); if (d->bufpool == NULL) { printk(KERN_ERR "aoe: cannot allocate bufpool for %ld.%d\n", d->aoemajor, d->aoeminor); goto err_disk; } d->blkq = blk_alloc_queue(GFP_KERNEL); if (!d->blkq) goto err_mempool; blk_queue_make_request(d->blkq, aoeblk_make_request); d->blkq->backing_dev_info.name = "aoe"; spin_lock_irqsave(&d->lock, flags); gd->major = AOE_MAJOR; gd->first_minor = d->sysminor * AOE_PARTITIONS; gd->fops = &aoe_bdops; gd->private_data = d; set_capacity(gd, d->ssize); snprintf(gd->disk_name, sizeof gd->disk_name, "etherd/e%ld.%d", d->aoemajor, d->aoeminor); gd->queue = d->blkq; d->gd = gd; d->flags &= ~DEVFL_GDALLOC; d->flags |= DEVFL_UP; spin_unlock_irqrestore(&d->lock, flags); add_disk(gd); aoedisk_add_sysfs(d); return; err_mempool: mempool_destroy(d->bufpool); err_disk: put_disk(gd); err: spin_lock_irqsave(&d->lock, flags); d->flags &= ~DEVFL_GDALLOC; spin_unlock_irqrestore(&d->lock, flags); }
/* alloc_disk and add_disk can sleep */ void aoeblk_gdalloc(void *vp) { struct aoedev *d = vp; struct gendisk *gd; ulong flags; gd = alloc_disk(AOE_PARTITIONS); if (gd == NULL) { printk(KERN_ERR "aoe: aoeblk_gdalloc: cannot allocate disk " "structure for %ld.%ld\n", d->aoemajor, d->aoeminor); spin_lock_irqsave(&d->lock, flags); d->flags &= ~DEVFL_WORKON; spin_unlock_irqrestore(&d->lock, flags); return; } d->bufpool = mempool_create(MIN_BUFS, mempool_alloc_slab, mempool_free_slab, buf_pool_cache); if (d->bufpool == NULL) { printk(KERN_ERR "aoe: aoeblk_gdalloc: cannot allocate bufpool " "for %ld.%ld\n", d->aoemajor, d->aoeminor); put_disk(gd); spin_lock_irqsave(&d->lock, flags); d->flags &= ~DEVFL_WORKON; spin_unlock_irqrestore(&d->lock, flags); return; } spin_lock_irqsave(&d->lock, flags); blk_queue_make_request(&d->blkq, aoeblk_make_request); gd->major = AOE_MAJOR; gd->first_minor = d->sysminor * AOE_PARTITIONS; gd->fops = &aoe_bdops; gd->private_data = d; gd->capacity = d->ssize; snprintf(gd->disk_name, sizeof gd->disk_name, "etherd/e%ld.%ld", d->aoemajor, d->aoeminor); gd->queue = &d->blkq; d->gd = gd; d->flags &= ~DEVFL_WORKON; d->flags |= DEVFL_UP; spin_unlock_irqrestore(&d->lock, flags); add_disk(gd); aoedisk_add_sysfs(d); printk(KERN_INFO "aoe: %012llx e%lu.%lu v%04x has %llu " "sectors\n", (unsigned long long)mac_addr(d->addr), d->aoemajor, d->aoeminor, d->fw_ver, (long long)d->ssize); }
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 setup_blk_device(struct ramdisk_dev* dev) { mutex_init(&dev->mutex); init_waitqueue_head(&dev->waitqueue); /* * Get some memory. */ memset (dev, 0, sizeof (struct ramdisk_dev)); dev->size = NSECTORS*HARDSECT_SIZE; dev->data = vmalloc(dev->size); if (dev->data == NULL) { printk (KERN_NOTICE "vmalloc failure.\n"); return; } spin_lock_init(&dev->lock); /* * The timer which "invalidates" the device. */ init_timer(&dev->timer); dev->timer.data = (unsigned long) dev; dev->timer.function = ramdisk_invalidate; dev->queue = blk_init_queue(ramdisk_request, &dev->lock); if (dev->queue == NULL) goto out_vfree; blk_queue_logical_block_size(dev->queue, HARDSECT_SIZE); dev->queue->queuedata = dev; /* * And the gendisk structure. */ dev->gd = alloc_disk(BLK_MINORS); if (! dev->gd) { printk (KERN_NOTICE "alloc_disk failure\n"); goto out_vfree; } dev->gd->major = blk_major; dev->gd->first_minor = BLK_MINORS; dev->gd->fops = &ramdisk_ops; dev->gd->queue = dev->queue; dev->gd->private_data = dev; snprintf (dev->gd->disk_name, 32, "ramdisk%c", 'a'); set_capacity(dev->gd, NSECTORS*(HARDSECT_SIZE/KERNEL_SECTOR_SIZE)); // set_capacity(dev->gd, 0); add_disk(dev->gd); return; out_vfree: if (dev->data) vfree(dev->data); }
/* * Allocate memory for a new zvol_state_t and setup the required * request queue and generic disk structures for the block device. */ static zvol_state_t * zvol_alloc(dev_t dev, const char *name) { zvol_state_t *zv; zv = kmem_zalloc(sizeof (zvol_state_t), KM_SLEEP); if (zv == NULL) goto out; zv->zv_queue = blk_init_queue(zvol_request, &zv->zv_lock); if (zv->zv_queue == NULL) goto out_kmem; #ifdef HAVE_BLK_QUEUE_FLUSH blk_queue_flush(zv->zv_queue, VDEV_REQ_FLUSH | VDEV_REQ_FUA); #else blk_queue_ordered(zv->zv_queue, QUEUE_ORDERED_DRAIN, NULL); #endif /* HAVE_BLK_QUEUE_FLUSH */ zv->zv_disk = alloc_disk(ZVOL_MINORS); if (zv->zv_disk == NULL) goto out_queue; zv->zv_queue->queuedata = zv; zv->zv_dev = dev; zv->zv_open_count = 0; strlcpy(zv->zv_name, name, MAXNAMELEN); mutex_init(&zv->zv_znode.z_range_lock, NULL, MUTEX_DEFAULT, NULL); avl_create(&zv->zv_znode.z_range_avl, zfs_range_compare, sizeof (rl_t), offsetof(rl_t, r_node)); zv->zv_znode.z_is_zvol = TRUE; spin_lock_init(&zv->zv_lock); list_link_init(&zv->zv_next); zv->zv_disk->major = zvol_major; zv->zv_disk->first_minor = (dev & MINORMASK); zv->zv_disk->fops = &zvol_ops; zv->zv_disk->private_data = zv; zv->zv_disk->queue = zv->zv_queue; snprintf(zv->zv_disk->disk_name, DISK_NAME_LEN, "%s%d", ZVOL_DEV_NAME, (dev & MINORMASK)); return zv; out_queue: blk_cleanup_queue(zv->zv_queue); out_kmem: kmem_free(zv, sizeof (zvol_state_t)); out: return NULL; }
static int __init looper_init(void) { if (filename == NULL) { printk(KERN_WARNING "looper: no filename defined"); return -1; } /* * Set up our internal device. */ Device.size = nsectors * logical_block_size; spin_lock_init(&Device.lock); Device.data = vmalloc(Device.size); if (Device.data == NULL) return -ENOMEM; /* * Get a request queue. */ Queue = blk_init_queue(looper_request, &Device.lock); if (Queue == NULL) goto out; blk_queue_logical_block_size(Queue, logical_block_size); /* * Get registered. */ major_num = register_blkdev(major_num, "looper"); if (major_num <= 0) { printk(KERN_WARNING "looper: unable to get major number\n"); goto out; } /* * And the gendisk structure. */ Device.gd = alloc_disk(16); if (!Device.gd) goto out_unregister; Device.gd->major = major_num; Device.gd->first_minor = 0; Device.gd->fops = &looper_ops; Device.gd->private_data = &Device; strcpy(Device.gd->disk_name, "looper0"); set_capacity(Device.gd, nsectors); Device.gd->queue = Queue; add_disk(Device.gd); return 0; out_unregister: unregister_blkdev(major_num, "looper"); out: vfree(Device.data); return -ENOMEM; }
/* * Allocate and register gendisk structure for device. */ int dasd_gendisk_alloc(struct dasd_block *block) { struct gendisk *gdp; struct dasd_device *base; int len; /* Make sure the minor for this device exists. */ base = block->base; if (base->devindex >= DASD_PER_MAJOR) return -EBUSY; gdp = alloc_disk(1 << DASD_PARTN_BITS); if (!gdp) return -ENOMEM; /* Initialize gendisk structure. */ gdp->major = DASD_MAJOR; gdp->first_minor = base->devindex << DASD_PARTN_BITS; gdp->fops = &dasd_device_operations; gdp->driverfs_dev = &base->cdev->dev; /* * Set device name. * dasda - dasdz : 26 devices * dasdaa - dasdzz : 676 devices, added up = 702 * dasdaaa - dasdzzz : 17576 devices, added up = 18278 * dasdaaaa - dasdzzzz : 456976 devices, added up = 475252 */ len = sprintf(gdp->disk_name, "dasd"); if (base->devindex > 25) { if (base->devindex > 701) { if (base->devindex > 18277) len += sprintf(gdp->disk_name + len, "%c", 'a'+(((base->devindex-18278) /17576)%26)); len += sprintf(gdp->disk_name + len, "%c", 'a'+(((base->devindex-702)/676)%26)); } len += sprintf(gdp->disk_name + len, "%c", 'a'+(((base->devindex-26)/26)%26)); } len += sprintf(gdp->disk_name + len, "%c", 'a'+(base->devindex%26)); if (base->features & DASD_FEATURE_READONLY || test_bit(DASD_FLAG_DEVICE_RO, &base->flags)) set_disk_ro(gdp, 1); gdp->private_data = block; gdp->queue = block->request_queue; block->gdp = gdp; set_capacity(block->gdp, 0); add_disk(block->gdp); return 0; }
/* * Allocate and register gendisk structure for device. */ int dasd_gendisk_alloc(struct dasd_device *device) { struct gendisk *gdp; int len; /* Make sure the minor for this device exists. */ if (device->devindex >= DASD_PER_MAJOR) return -EBUSY; gdp = alloc_disk(1 << DASD_PARTN_BITS); if (!gdp) return -ENOMEM; /* Initialize gendisk structure. */ gdp->major = DASD_MAJOR; gdp->first_minor = device->devindex << DASD_PARTN_BITS; gdp->fops = &dasd_device_operations; gdp->driverfs_dev = &device->cdev->dev; /* * Set device name. * dasda - dasdz : 26 devices * dasdaa - dasdzz : 676 devices, added up = 702 * dasdaaa - dasdzzz : 17576 devices, added up = 18278 * dasdaaaa - dasdzzzz : 456976 devices, added up = 475252 */ len = sprintf(gdp->disk_name, "dasd"); if (device->devindex > 25) { if (device->devindex > 701) { if (device->devindex > 18277) len += sprintf(gdp->disk_name + len, "%c", 'a'+(((device->devindex-18278) /17576)%26)); len += sprintf(gdp->disk_name + len, "%c", 'a'+(((device->devindex-702)/676)%26)); } len += sprintf(gdp->disk_name + len, "%c", 'a'+(((device->devindex-26)/26)%26)); } len += sprintf(gdp->disk_name + len, "%c", 'a'+(device->devindex%26)); sprintf(gdp->devfs_name, "dasd/%s", device->cdev->dev.bus_id); if (test_bit(DASD_FLAG_RO, &device->flags)) set_disk_ro(gdp, 1); gdp->private_data = device; gdp->queue = device->request_queue; device->gdp = gdp; set_capacity(device->gdp, 0); add_disk(device->gdp); return 0; }
static int test_init_module(void) { int rc; printk("starting module\n"); ltp_pm_dev = pm_register(PM_UNKNOWN_DEV, 0, ltp_pm_callback); rc = register_blkdev(INCLUDEMAJOR, DEVICE_NAME); printk("BLK INC - result =%d major %d\n", rc, INCLUDEMAJOR); if (rc < 0) { printk("Failed to register device.\n"); return rc; } gd_ptr = kmalloc(sizeof(struct gendisk *), GFP_KERNEL); if (!gd_ptr) { printk(KERN_ALERT "ERROR getting memory !!!\n"); return 0; } printk("major = %d\n", Major); gd_ptr = alloc_disk(1); printk(KERN_ALERT "gd_ptr after alloc = %p \n", gd_ptr); gd_ptr->major = INCLUDEMAJOR; gd_ptr->first_minor = 0; gd_ptr->fops = &bdops; // gd_ptr->minor_shift= MINOR_SHIFT_BITS; gd_ptr->driverfs_dev = NULL; gd_ptr->capacity = MAX_NUM_DISKS; // gd_ptr->disk_de = NULL; gd_ptr->flags = genhd_flags; sprintf(gd_ptr->disk_name, DEVICE_NAME); add_disk(gd_ptr); printk("major = %d\n", Major); test_acpi(); test_vga(); test_lockd(); test_sunrpc_auth(); test_nfsfh(); test_sunrpc_cache(); test_sunrpc_svc(); test_sunrpc_timer(); printk("finished module\n"); return 0; }
static int __init virtualblockdevice_init(void) { int ret; printk(KERN_ALERT "VirtualBlockDevice: Entry virtualblockdevice_init !\n"); ret = register_blkdev( virtualblockdevice_major, VIRTUALBLOCKDEVICE_NAME ); if( 0 > ret ) { printk(KERN_ALERT "VirtualBlockDevice: Failure to register block device: virtualblockdevice ! Major: %d\tErrno: %d !\n", virtualblockdevice_major, ret); goto failure_register_blkdev; } virtualblockdevice_major = ret; printk(KERN_ALERT "VirtualBlockDevice: Success to register block device: virtualblockdevice ! Major: %d !\n", virtualblockdevice_major); // get request_queue virtualblockdevice_queue = blk_init_queue( virtualblockdevice_do_request, NULL ); if( !virtualblockdevice_queue ) { printk(KERN_ALERT "VirtualBlockDevice: Failure to init request_queue !\n"); ret = -ENOMEM; goto failure_init_queue; } printk(KERN_ALERT "VirtualBlockDevice: Success to init request_queue !\n"); // get gendisk virtualblockdevice_disk = alloc_disk( 1 ); if( !virtualblockdevice_disk ) { printk(KERN_ALERT "VirtualBlockDevice: Failure to allocate gendisk !\n"); ret = -ENOMEM; goto failure_alloc_disk; } printk(KERN_ALERT "VirtualBlockDevice: Success to allocate gendisk !\n"); // initialize gendisk strcpy( virtualblockdevice_disk->disk_name, VIRTUALBLOCKDEVICE_NAME ); virtualblockdevice_disk->major = virtualblockdevice_major; virtualblockdevice_disk->first_minor = virtualblockdevice_minor; virtualblockdevice_disk->fops = &virtualblockdevice_fops; virtualblockdevice_disk->queue = virtualblockdevice_queue; set_capacity( virtualblockdevice_disk, ( VIRTUALBLOCKDEVICE_DISK_CAPACITY >> 9 ) ); // add gendisk to kernel add_disk( virtualblockdevice_disk ); return 0; failure_alloc_disk: blk_cleanup_queue( virtualblockdevice_queue ); failure_init_queue: unregister_blkdev( virtualblockdevice_major, VIRTUALBLOCKDEVICE_NAME ); failure_register_blkdev: return ret; }
int run_sparse (const char *cmd, size_t argc, char *argv[]) { if (argc != 2) { fprintf (stderr, _("use 'sparse file size' to create a sparse image\n")); return -1; } if (alloc_disk (argv[0], argv[1], 1, 1) == -1) return -1; return 0; }
static int __init chargement (void) { int ret; if ((nb_sect_exemple <= 0) || (lg_sect_exemple <= 0)) return -EINVAL; data_exemple = vmalloc(nb_sect_exemple * lg_sect_exemple); if (data_exemple == NULL) return -ENOMEM; ret = register_blkdev(majeur_exemple, nom_exemple); if (ret < 0) { vfree(data_exemple); return ret; } if (majeur_exemple == 0) majeur_exemple = ret; spin_lock_init(& spinlock_exemple); request_queue_exemple = blk_init_queue(request_exemple, & spinlock_exemple); if (request_queue_exemple == NULL) { unregister_blkdev(majeur_exemple, nom_exemple); vfree(data_exemple); return -ENOMEM; } gendisk_exemple = alloc_disk(NB_MINEURS); if (gendisk_exemple == NULL) { blk_cleanup_queue(request_queue_exemple); unregister_blkdev(majeur_exemple, nom_exemple); vfree(data_exemple); return -ENOMEM; } gendisk_exemple->major = majeur_exemple; gendisk_exemple->first_minor = 0; gendisk_exemple->fops = & devops_exemple; gendisk_exemple->queue = request_queue_exemple; snprintf(gendisk_exemple->disk_name, 32, nom_exemple); /* La capacite doit toujours etre indiquee en nombre de secteurs * de 512 octets. Il faut donc faire une conversion. */ set_capacity(gendisk_exemple, nb_sect_exemple * lg_sect_exemple / 512); add_disk(gendisk_exemple); return 0; }
/* * Set up our internal device. */ static void setup_device(struct sbull_dev *dev, int which) { /* * Get some memory. */ memset (dev, 0, sizeof (struct sbull_dev)); dev->size = nsectors*hardsect_size; dev->data = vmalloc(dev->size); if (dev->data == NULL) { printk (KERN_NOTICE "vmalloc failure.\n"); return; } spin_lock_init(&dev->lock); /* * The timer which "invalidates" the device. */ init_timer(&dev->timer); dev->timer.data = (unsigned long) dev; dev->timer.function = sbull_invalidate; dev->queue = blk_init_queue(sbull_request, &dev->lock); if (dev->queue == NULL) goto out_vfree; blk_queue_logical_block_size(dev->queue, hardsect_size); dev->queue->queuedata = dev; /* * And the gendisk structure. */ dev->gd = alloc_disk(SBULL_MINORS); if (! dev->gd) { printk (KERN_NOTICE "alloc_disk failure\n"); goto out_vfree; } dev->gd->major = sbull_major; dev->gd->first_minor = which*SBULL_MINORS; dev->gd->fops = &sbull_ops; dev->gd->queue = dev->queue; dev->gd->private_data = dev; snprintf (dev->gd->disk_name, 32, "sbull%c", which + 'a'); set_capacity(dev->gd, nsectors*(hardsect_size/KERNEL_SECTOR_SIZE)); add_disk(dev->gd); return; out_vfree: if (dev->data) vfree(dev->data); }
static int __init stheno_module_init( void ) { stheno_major = register_blkdev( 0, MODNAME ); if( stheno_major <= 0 ){ printk( KERN_WARNING "register_blkdev failed\n" ); return stheno_major; } spin_lock_init( &stheno_lock ); stheno_queue = blk_init_queue( stheno_request, // &stheno_lock ); if( ! stheno_queue ){ printk( KERN_WARNING "blk_init_queue failed\n" ); unregister_blkdev( stheno_major, MODNAME ); return -ENOMEM; } blk_queue_logical_block_size( stheno_queue, SECT_SIZE ); blk_queue_max_sectors( stheno_queue, MAX_SECTORS ); blk_queue_bounce_limit(stheno_queue, BLK_BOUNCE_ANY); stheno_gd = alloc_disk( MINOR_COUNT ); if( ! stheno_gd ){ printk( KERN_WARNING "alloc_disk failed\n" ); blk_cleanup_queue( stheno_queue ); unregister_blkdev( stheno_major, MODNAME ); return -ENOMEM; } sprintf( stheno_gd->disk_name, "%s", MODNAME ); // stheno_gd->queue = stheno_queue; // stheno_gd->major = stheno_major; stheno_gd->first_minor = 0; stheno_gd->fops = &stheno_fops; // set_capacity( stheno_gd, SECT_NUM ); sema_init(&stheno_sem, 1); init_waitqueue_head(&stheno_process_q); stheno_thread = kthread_create(stheno_do_request, 0, "sthenod"); wake_up_process(stheno_thread); add_disk( stheno_gd ); printk( KERN_INFO "stheno is loaded\n" ); printk( KERN_INFO "major = %d\n", stheno_major ); return 0; }
static int __init sbd_init(void) { crypt_cipher = crypto_alloc_cipher("aes", 0, 0); /* Set up our internal device. */ Device.size = nsectors * logical_block_size; spin_lock_init(&Device.lock); Device.data = vmalloc(Device.size); if (Device.data == NULL) { return -ENOMEM; } /* Get a request queue. */ Queue = blk_init_queue(sbd_request, &Device.lock); if (Queue == NULL) { goto out; } blk_queue_logical_block_size(Queue, logical_block_size); /* Get registered. */ major_num = register_blkdev(major_num, "sbd"); if (major_num < 0) { printk(KERN_WARNING "sbd: unable to get major number\n"); goto out; } /* And the gendisk structure. */ Device.gd = alloc_disk(16); if (!Device.gd) { goto out_unregister; } Device.gd->major = major_num; Device.gd->first_minor = 0; Device.gd->fops = &sbd_ops; Device.gd->private_data = &Device; strcpy(Device.gd->disk_name, "sbd0"); set_capacity(Device.gd, nsectors); Device.gd->queue = Queue; add_disk(Device.gd); return 0; out_unregister: unregister_blkdev(major_num, "sbd"); out: vfree(Device.data); return -ENOMEM; }
/* * Initializes the block layer interfaces. */ static int sd_init_blk_dev(struct sd_host *host) { struct gendisk *disk; struct request_queue *queue; int channel; int retval; channel = to_channel(exi_get_exi_channel(host->exi_device)); /* queue */ retval = -ENOMEM; spin_lock_init(&host->queue_lock); queue = blk_init_queue(sd_request_func, &host->queue_lock); if (!queue) { sd_printk(KERN_ERR, "error initializing queue\n"); goto err_blk_init_queue; } blk_queue_dma_alignment(queue, EXI_DMA_ALIGN); blk_queue_max_phys_segments(queue, 1); blk_queue_max_hw_segments(queue, 1); blk_queue_max_sectors(queue, 8); queue_flag_set_unlocked(QUEUE_FLAG_NONROT, queue); queue->queuedata = host; host->queue = queue; /* disk */ disk = alloc_disk(1 << MMC_SHIFT); if (!disk) { sd_printk(KERN_ERR, "error allocating disk\n"); goto err_alloc_disk; } disk->major = SD_MAJOR; disk->first_minor = channel << MMC_SHIFT; disk->fops = &sd_fops; sprintf(disk->disk_name, "%s%c", SD_NAME, 'a' + channel); disk->private_data = host; disk->queue = host->queue; host->disk = disk; retval = 0; goto out; err_alloc_disk: blk_cleanup_queue(host->queue); host->queue = NULL; err_blk_init_queue: out: return retval; }
/* alloc_disk and add_disk can sleep */ void aoeblk_gdalloc(void *vp) { struct aoedev *d = vp; struct gendisk *gd; ulong flags; gd = alloc_disk(AOE_PARTITIONS); if (gd == NULL) { printk(KERN_ERR "aoe: cannot allocate disk structure for %ld.%ld\n", d->aoemajor, d->aoeminor); spin_lock_irqsave(&d->lock, flags); d->flags &= ~DEVFL_GDALLOC; spin_unlock_irqrestore(&d->lock, flags); return; } d->bufpool = mempool_create_slab_pool(MIN_BUFS, buf_pool_cache); if (d->bufpool == NULL) { printk(KERN_ERR "aoe: cannot allocate bufpool for %ld.%ld\n", d->aoemajor, d->aoeminor); put_disk(gd); spin_lock_irqsave(&d->lock, flags); d->flags &= ~DEVFL_GDALLOC; spin_unlock_irqrestore(&d->lock, flags); return; } spin_lock_irqsave(&d->lock, flags); blk_queue_make_request(&d->blkq, aoeblk_make_request); gd->major = AOE_MAJOR; gd->first_minor = d->sysminor * AOE_PARTITIONS; gd->fops = &aoe_bdops; gd->private_data = d; gd->capacity = d->ssize; snprintf(gd->disk_name, sizeof gd->disk_name, "etherd/e%ld.%ld", d->aoemajor, d->aoeminor); gd->queue = &d->blkq; d->gd = gd; d->flags &= ~DEVFL_GDALLOC; d->flags |= DEVFL_UP; spin_unlock_irqrestore(&d->lock, flags); add_disk(gd); aoedisk_add_sysfs(d); }
static int __init simpleblockinit(void) { /* * Set up our internal device. */ Device.size = nsectors*hardsect_size; spin_lock_init(&Device.lock); Device.data = vmalloc(Device.size); if (Device.data == NULL) return -ENOMEM; /* * Get a request queue. */ Queue = blk_init_queue(simpleblockrequest, &Device.lock); if (Queue == NULL) goto out; blk_queue_hardsect_size(Queue, hardsect_size); /* * Get registered. */ major_num = register_blkdev(major_num, "sbd"); if (major_num <= 0) { printk(KERN_WARNING "sbd: unable to get major number\n"); goto out; } /* * And the gendisk structure. */ Device.gd = alloc_disk(16); if (! Device.gd) goto out_unregister; Device.gd->major = major_num; Device.gd->first_minor = 0; Device.gd->fops = &simpleblockops; Device.gd->private_data = &Device; strcpy (Device.gd->disk_name, "sbd0"); set_capacity(Device.gd, nsectors*(hardsect_size/KERNEL_SECTOR_SIZE)); Device.gd->queue = Queue; add_disk(Device.gd); return 0; out_unregister: unregister_blkdev(major_num, "sbd"); out: vfree(Device.data); return -ENOMEM; }
static int __init my_init (void) { disk_size = diskmb * 1024 * 1024; spin_lock_init (&lock); if (!(my_dev = vmalloc (disk_size))) return -ENOMEM; if (!(my_request_queue = blk_init_queue (my_request, &lock))) { vfree (my_dev); return -ENOMEM; } #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31) blk_queue_hardsect_size (my_request_queue, sector_size); #else blk_queue_logical_block_size (my_request_queue, sector_size); #endif mybdrv_ma_no = register_blkdev (mybdrv_ma_no, MY_DEVICE_NAME); if (mybdrv_ma_no < 0) { printk (KERN_ERR "Failed registering mybdrv, returned %d\n", mybdrv_ma_no); vfree (my_dev); return mybdrv_ma_no; } if (!(my_gd = alloc_disk (16))) { unregister_blkdev (mybdrv_ma_no, MY_DEVICE_NAME); vfree (my_dev); return -ENOMEM; } my_gd->major = mybdrv_ma_no; my_gd->first_minor = 0; my_gd->fops = &mybdrv_fops; strcpy (my_gd->disk_name, MY_DEVICE_NAME); my_gd->queue = my_request_queue; set_capacity (my_gd, disk_size / sector_size); add_disk (my_gd); printk (KERN_INFO "device successfully registered, Major No. = %d\n", mybdrv_ma_no); printk (KERN_INFO "Capacity of ram disk is: %d MB\n", diskmb); return 0; }
static int __init stackbd_init(void) { /* Set up our internal device */ spin_lock_init(&stackbd.lock); /* blk_alloc_queue() instead of blk_init_queue() so it won't set up the * queue for requests. */ if (!(stackbd.queue = blk_alloc_queue(GFP_KERNEL))) { printk("stackbd: alloc_queue failed\n"); return -EFAULT; } blk_queue_make_request(stackbd.queue, stackbd_make_request); blk_queue_logical_block_size(stackbd.queue, LOGICAL_BLOCK_SIZE); /* Get registered */ if ((major_num = register_blkdev(major_num, STACKBD_NAME)) < 0) { printk("stackbd: unable to get major number\n"); goto error_after_alloc_queue; } /* Gendisk structure */ if (!(stackbd.gd = alloc_disk(16))) goto error_after_redister_blkdev; stackbd.gd->major = major_num; stackbd.gd->first_minor = 0; stackbd.gd->fops = &stackbd_ops; stackbd.gd->private_data = &stackbd; strcpy(stackbd.gd->disk_name, STACKBD_NAME_0); stackbd.gd->queue = stackbd.queue; add_disk(stackbd.gd); printk("stackbd: init done\n"); return 0; error_after_redister_blkdev: unregister_blkdev(major_num, STACKBD_NAME); error_after_alloc_queue: blk_cleanup_queue(stackbd.queue); return -EFAULT; }
static int swim3_attach(struct macio_dev *mdev, const struct of_device_id *match) { struct gendisk *disk; int index, rc; index = floppy_count++; if (index >= MAX_FLOPPIES) return -ENXIO; /* Add the drive */ rc = swim3_add_device(mdev, index); if (rc) return rc; /* Now register that disk. Same comment about failure handling */ disk = disks[index] = alloc_disk(1); if (disk == NULL) return -ENOMEM; disk->queue = blk_init_queue(do_fd_request, &swim3_lock); if (disk->queue == NULL) { put_disk(disk); return -ENOMEM; } blk_queue_bounce_limit(disk->queue, BLK_BOUNCE_HIGH); disk->queue->queuedata = &floppy_states[index]; if (index == 0) { /* If we failed, there isn't much we can do as the driver is still * too dumb to remove the device, just bail out */ if (register_blkdev(FLOPPY_MAJOR, "fd")) return 0; } disk->major = FLOPPY_MAJOR; disk->first_minor = index; disk->fops = &floppy_fops; disk->private_data = &floppy_states[index]; disk->flags |= GENHD_FL_REMOVABLE; sprintf(disk->disk_name, "fd%d", index); set_capacity(disk, 2880); add_disk(disk); return 0; }
int init_module(void) { int result; printk(KERN_ALERT "ltpdev_init_module \n"); ltp_pm_dev = pm_register(PM_UNKNOWN_DEV, 0, ltp_pm_callback); result = register_blkdev(ltp_fs_major, LTP_FS_DEV_NAME); printk(KERN_ALERT "LTP FS: register_blkdev result=%d major %d\n",result, ltp_fs_major); if (result < 0) { printk(KERN_ALERT "LTP FS: can't get major %d\n",ltp_fs_major); return result; } gd_ptr = kmalloc(sizeof(struct gendisk *), GFP_KERNEL); if (!gd_ptr) { printk(KERN_ALERT "ERROR getting memory !!!\n"); return 0; } gd_ptr = alloc_disk(1); printk(KERN_ALERT "gd_ptr after alloc = %p \n",gd_ptr); gd_ptr->major = ltp_fs_major; gd_ptr->first_minor = 0; gd_ptr->fops = &blkops; gd_ptr->driverfs_dev = NULL; gd_ptr->capacity = MAX_NUM_DISKS; gd_ptr->flags = genhd_flags; sprintf(gd_ptr->disk_name, LTP_FS_DEV_NAME); add_disk(gd_ptr); return 0; }
/* * Allocate memory for a new zvol_state_t and setup the required * request queue and generic disk structures for the block device. */ static zvol_state_t * zvol_alloc(dev_t dev, const char *name) { zvol_state_t *zv; zv = kmem_zalloc(sizeof (zvol_state_t), KM_SLEEP); list_link_init(&zv->zv_next); zv->zv_queue = blk_alloc_queue(GFP_ATOMIC); if (zv->zv_queue == NULL) goto out_kmem; blk_queue_make_request(zv->zv_queue, zvol_request); blk_queue_set_write_cache(zv->zv_queue, B_TRUE, B_TRUE); zv->zv_disk = alloc_disk(ZVOL_MINORS); if (zv->zv_disk == NULL) goto out_queue; zv->zv_queue->queuedata = zv; zv->zv_dev = dev; zv->zv_open_count = 0; strlcpy(zv->zv_name, name, MAXNAMELEN); zfs_rlock_init(&zv->zv_range_lock); zv->zv_disk->major = zvol_major; zv->zv_disk->first_minor = (dev & MINORMASK); zv->zv_disk->fops = &zvol_ops; zv->zv_disk->private_data = zv; zv->zv_disk->queue = zv->zv_queue; snprintf(zv->zv_disk->disk_name, DISK_NAME_LEN, "%s%d", ZVOL_DEV_NAME, (dev & MINORMASK)); return (zv); out_queue: blk_cleanup_queue(zv->zv_queue); out_kmem: kmem_free(zv, sizeof (zvol_state_t)); return (NULL); }
__kernel_dev_t _lkl_disk_add_disk(void *data, int sectors) { struct lkl_disk_dev *dev; if (failed_init) return 0; if (!(dev=kzalloc(sizeof(*dev), GFP_KERNEL))) return 0; dev->data=data; spin_lock_init(&dev->lock); if (!(dev->queue=blk_init_queue(lkl_disk_request, &dev->lock))) { kfree(dev); return 0; } blk_queue_hardsect_size(dev->queue, 512); dev->queue->queuedata = dev; if (!(dev->gd=alloc_disk(1))) { kfree(dev); /* FIXME: del queue? */ return 0; } dev->gd->major = major; dev->gd->first_minor = disks; dev->gd->fops = &lkl_disk_ops; dev->gd->queue = dev->queue; dev->gd->private_data = dev; snprintf (dev->gd->disk_name, 32, "lkldisk%d", disks); set_capacity(dev->gd, sectors); add_disk(dev->gd); disks++; printk("lkldisk: attached %s @ dev=%d:%d\n", dev->gd->disk_name, dev->gd->major, dev->gd->first_minor); return new_encode_dev(MKDEV(dev->gd->major, dev->gd->first_minor)); }
/* * Allocate memory for a new zvol_state_t and setup the required * request queue and generic disk structures for the block device. */ static zvol_state_t * zvol_alloc(dev_t dev, const char *name) { zvol_state_t *zv; zv = kmem_zalloc(sizeof (zvol_state_t), KM_SLEEP); if (zv == NULL) goto out; zv->zv_queue = blk_init_queue(zvol_request, &zv->zv_lock); if (zv->zv_queue == NULL) goto out_kmem; zv->zv_disk = alloc_disk(ZVOL_MINORS); if (zv->zv_disk == NULL) goto out_queue; zv->zv_queue->queuedata = zv; zv->zv_dev = dev; zv->zv_open_count = 0; strlcpy(zv->zv_name, name, DISK_NAME_LEN); mutex_init(&zv->zv_znode.z_range_lock, NULL, MUTEX_DEFAULT, NULL); avl_create(&zv->zv_znode.z_range_avl, zfs_range_compare, sizeof (rl_t), offsetof(rl_t, r_node)); spin_lock_init(&zv->zv_lock); list_link_init(&zv->zv_next); zv->zv_disk->major = zvol_major; zv->zv_disk->first_minor = (dev & MINORMASK); zv->zv_disk->fops = &zvol_ops; zv->zv_disk->private_data = zv; zv->zv_disk->queue = zv->zv_queue; snprintf(zv->zv_disk->disk_name, DISK_NAME_LEN, "%s", name); return zv; out_queue: blk_cleanup_queue(zv->zv_queue); out_kmem: kmem_free(zv, sizeof (zvol_state_t)); out: return NULL; }
static int __devinit swim3_attach(struct macio_dev *mdev, const struct of_device_id *match) { int i, rc; struct gendisk *disk; /* Add the drive */ rc = swim3_add_device(mdev, floppy_count); if (rc) return rc; /* Now create the queue if not there yet */ if (swim3_queue == NULL) { /* If we failed, there isn't much we can do as the driver is still * too dumb to remove the device, just bail out */ if (register_blkdev(FLOPPY_MAJOR, "fd")) return 0; swim3_queue = blk_init_queue(do_fd_request, &swim3_lock); if (swim3_queue == NULL) { unregister_blkdev(FLOPPY_MAJOR, "fd"); return 0; } } /* Now register that disk. Same comment about failure handling */ i = floppy_count++; disk = disks[i] = alloc_disk(1); if (disk == NULL) return 0; disk->major = FLOPPY_MAJOR; disk->first_minor = i; disk->fops = &floppy_fops; disk->private_data = &floppy_states[i]; disk->queue = swim3_queue; disk->flags |= GENHD_FL_REMOVABLE; sprintf(disk->disk_name, "fd%d", i); set_capacity(disk, 2880); add_disk(disk); return 0; }
static int sm_probe(struct device* dev) { struct scsi_device *sdp = to_scsi_device(dev); int error = -ENODEV; if(sdp->type != TYPE_MEM) goto OUT; LogPath(); struct gendisk* gd = NULL; gd = alloc_disk(1); if(!gd) { Log("[Error] alloc_disk failed."); return -1; } gd->major = SM_MAJOR; gd->first_minor = 0; gd->fops = &sm_fops; gd->private_data = sdp; sprintf(gd->disk_name,"sm-scsi"); gd->queue = sdp->request_queue; gd->driverfs_dev = &sdp->sdev_gendev; //gd->flags = GENHD_FL_DRIVERFS; if(sdp->removable) gd->flags |= GENHD_FL_REMOVABLE; //dev->p->driver_data = (void*)gd; dev_set_drvdata(dev,(void*)gd); sm_spinup_mem_disk(sdp); sm_read_capacity(sdp); set_capacity(gd,g_mem_capacity >> 9); blk_queue_prep_rq(sdp->request_queue,sm_prep_fn); add_disk(gd); return 0; OUT: return error; }