C++ register_blkdev函数代码示例

static int tc01(void)
{
	int major1, major2;
	int pass = 1;

	prk_info("Test Case 1: register_blkdev() with auto allocating "
		"major numbers (major=0)\n");

	major1 = register_blkdev(0, BLK_DEV_NAME);
	prk_debug("major1 = %i\n", major1);

	major2 = register_blkdev(0, BLK_DEV_NAME);
	prk_debug("major2 = %i\n", major2);

	if (major1 >= 0) {
		unregister_blkdev(major1, BLK_DEV_NAME);
	} else {
		pass = 0;
		prk_debug("1st call to register_blkdev() failed, error %i\n",
			major1);
	}

	if (major2 >= 0) {
		unregister_blkdev(major2, BLK_DEV_NAME);
	} else {
		pass = 0;
		prk_debug("2nd call to register_blkdev() failed, error %i\n",
			major2);
	}

	prk_info("Test Case Result: %s\n", result_str(pass));
	return pass;
}

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;
}

void register_block_driver(unsigned int major, const char *name,
		struct block_device *(*get_device)(unsigned int),
		struct file_operations *fops)
{
	blkdev[major].get_device = get_device;
	register_blkdev(major, name, fops ? fops : &blkdev_generic_fops);
}

static int __init ramblock_init(void)
{
    /* 1. Allocate gendisk struct */
    ramblock_disk = alloc_disk(16);

    /* 2. Configure */
    /* 2.1 Allocate/Configure a queue which supporting read/write capabilities */
	if (!(ramblock_queue = blk_init_queue(do_ramblock_request, &ramblock_lock)))
		return -ENOMEM;
	ramblock_disk->queue = ramblock_queue;


    /* 2.2 Configure other properties: such as volume, etc */
    major = register_blkdev(0, "ramblock");
    
	ramblock_disk->major = major;
	ramblock_disk->first_minor = 0;
	sprintf(ramblock_disk->disk_name, "ramblock");
	ramblock_disk->fops = &ramblock_fops;
	set_capacity(ramblock_disk, RAMBLOCK_SIZE / 512);  /* 512 bytes per sector */


    /* 3. Register */
    add_disk(ramblock_disk);
    
    return 0;
}

static int __init tzmem_blkdev_init(void)
{
#ifdef MTEE_TZMEM_DBG
	pr_warn("====> tzmem_blkdev_init\n");
#endif

	if (register_blkdev(IO_NODE_MAJOR_TZMEM, DEV_TZMEM)) {
		pr_debug(MTEE_TZMEM_TAG "[%s] tzmem_blkdev_init: register_blkdev error\n", MODULE_NAME);
		return -EFAULT;
	}

	tz_client_dev = MKDEV(IO_NODE_MAJOR_TZMEM, IO_NODE_MINOR_TZMEM);
	blk_register_region(tz_client_dev, IO_NODE_NUMBER_TZMEM,
		THIS_MODULE, tzmem_blk_probe, NULL, NULL);

#if 0
	/* create /dev/tzmem automaticly */
	pTzClass = class_create(THIS_MODULE, DEV_TZMEM);
	if (IS_ERR(pTzClass)) {
		int ret = PTR_ERR(pTzClass);
		pr_debug(MTEE_TZMEM_TAG "[%s] could not create class for the device, ret:%d\n", MODULE_NAME, ret);
		return ret;
	}
	pTzDevice = device_create(pTzClass, NULL, tz_client_dev, NULL, DEV_TZMEM);
#endif

	return 0;
}

/* ---------------------------------------------------------------------
 * 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 int __init osprd_init(void)
{
	int i, r;

	// shut up the compiler
	(void) for_each_open_file;
#ifndef osp_spin_lock
	(void) osp_spin_lock;
	(void) osp_spin_unlock;
#endif

	/* Register the block device name. */
	if (register_blkdev(OSPRD_MAJOR, "osprd") < 0) {
		printk(KERN_WARNING "osprd: unable to get major number\n");
		return -EBUSY;
	}

	/* Initialize the device structures. */
	for (i = r = 0; i < NOSPRD; i++)
		if (setup_device(&osprds[i], i) < 0)
			r = -EINVAL;

	if (r < 0) {
		printk(KERN_EMERG "osprd: can't set up device structures\n");
		osprd_exit();
		return -EBUSY;
	} else
		return 0;
}

static int ramblock_init(void)
{
	/* 1. 分配一个gendisk结构体 */
	ramblock_disk = alloc_disk(16); /* 次设备号个数: 分区个数+1 */

	/* 2. 设置 */
	/* 2.1 分配/设置队列: 提供读写能力 */
	ramblock_queue = blk_init_queue(do_ramblock_request, &ramblock_lock);
	ramblock_disk->queue = ramblock_queue;
	
	/* 2.2 设置其他属性: 比如容量 */
	major = register_blkdev(0, "ramblock");  /* cat /proc/devices */	
	ramblock_disk->major       = major;
	ramblock_disk->first_minor = 0;
	sprintf(ramblock_disk->disk_name, "ramblock");
	ramblock_disk->fops        = &ramblock_fops;
	set_capacity(ramblock_disk, RAMBLOCK_SIZE / 512);

	/* 3. 硬件相关操作 */
	ramblock_buf = kzalloc(RAMBLOCK_SIZE, GFP_KERNEL);

	/* 4. 注册 */
	add_disk(ramblock_disk);

	return 0;
}

static int __init sbull_init(void)
{
	int i;
	/*
	* 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;
}

static int trd_init(void)
{
	int i;

	trd_pages = (TRD_SIZE + (PAGE_SIZE-1)) >> PAGE_SHIFT;

	if (register_blkdev(MAJOR_NR, DEVICE_NAME, &trd_fops)) {
		printk(KERN_ERR DEVICE_NAME ": Unable to register_blkdev(%d)\n", MAJOR_NR);
		return -EBUSY;
	}

	blk_queue_make_request(BLK_DEFAULT_QUEUE(MAJOR_NR), trd_make_request);
	for (i=0;i<MAX_DEVS;i++) {
		trd_blocksizes[i] = TRD_BLOCK_SIZE;
		trd_blk_sizes[i] = trd_size;
	}

	blksize_size[MAJOR_NR] = trd_blocksizes;
	blk_size[MAJOR_NR] = trd_blk_sizes;

	printk(KERN_DEBUG DEVICE_NAME ": trd initialised size=%dk\n", 
	       trd_size);

	return 0;
}

static int __init ramhd_init(void)
{
	int i;

	ramhd_space_init();
	alloc_ramdev();

	ramhd_major = register_blkdev(0, RAMHD_NAME);

	for (i=0; i<RAMHD_MAX_DEVICE; i++)
	{
		rdev[i]->data = sdisk[i];
		rdev[i]->queue = blk_alloc_queue(GFP_KERNEL);
		blk_queue_make_request(rdev[i]->queue, ramhd_make_request);
		rdev[i]->gd = alloc_disk(RAMHD_MAX_PARTITIONS);
		rdev[i]->gd->major = ramhd_major;
		rdev[i]->gd->first_minor = i*RAMHD_MAX_PARTITIONS;
		rdev[i]->gd->fops = &ramhd_fops;
		rdev[i]->gd->queue = rdev[i]->queue;
		rdev[i]->gd->private_data = rdev[i];
		sprintf(rdev[i]->gd->disk_name, "ramhd%c", 'a'+i);
		rdev[i]->gd->flags |= GENHD_FL_SUPPRESS_PARTITION_INFO;
		set_capacity(rdev[i]->gd, RAMHD_SECTOR_TOTAL);
		add_disk(rdev[i]->gd);
	}
	return 0;
}

static int __init imgrement_init(void)
{
    char* err;
    struct imgrement_device *dev;

    imgrement_device = kzalloc(sizeof(struct imgrement_device), GFP_KERNEL);
    _astgo(imgrement_device != NULL, "Error allocating", err, init_error);
    dev = imgrement_device;

    dev->major = register_blkdev(0, DRIVER_NAME);
    _astgo(dev->major > 0, "Error register block device", err, init_error);

    dev->base_dev = blkdev_get_by_path("/dev/sdb", FMODE_READ, NULL);
    _astgo(dev->base_dev != NULL, "Error getting base block device", err, init_error);

    dev->base_queue = bdev_get_queue(dev->base_dev);
    _astgo(dev->base_queue != NULL, "Error getting queue", err, init_error);
    dev->orig_req_fn = dev->base_queue->make_request_fn;
    dev->base_queue->make_request_fn = trace_request_fn;

    LOG("%s trace initialization succeeded", dev->base_dev->bd_disk->disk_name);
    return 0;

init_error:
    LOG_VAR(err);
    imgrement_exit();
    return -1;
}

static int ramblock_init(void)
{
    major = register_blkdev(0, "ramblock");
	
	/* 1.分配一个gendisk结构体 */
	/* 这里的16表示分区的个数 15个分区 */
    ramblock_gendisk = alloc_disk(16);
	
	/* 2. 设置 */
    ramblock_gendisk->major = major;
    ramblock_gendisk->first_minor = 0;
	sprintf(ramblock_gendisk->disk_name, "ramblock");
    ramblock_gendisk->fops = &ramblock_fops;

	/* 2.1 分配/设置队列:提供读写能力 */
    ramblock_request_queue = blk_init_queue(do_ramblock_request, &ramblock_lock);
    ramblock_gendisk->queue = ramblock_request_queue;
	
	/* 2.2 设置其它属性:比如容量 */
	set_capacity(ramblock_gendisk, RAMBLOCK_SIZE / 512);

	/* 3. 硬件相关操作 */
	if (NULL == (ramblock_buf = kzalloc(RAMBLOCK_SIZE, GFP_KERNEL)))
		return -ENOMEM;
	
	/* 4. 注册 */
    add_disk(ramblock_gendisk);
	
	return 0;
}

/* ---------------------------------------------------------------------
 * Module init/exit routines
 */
static int __init dm3730logic_cf_init(void)
{
	int rc;

	// printk(KERN_INFO "%s:%d\n", __FUNCTION__, __LINE__);

	cf_major = register_blkdev(cf_major, "omap-cf");
	if (cf_major <= 0) {
		rc = -ENOMEM;
		goto err_blk;
	}

#if defined(CONFIG_DEBUG_FS) && defined(DEBUG)
	(void)debugfs_create_file("cf-debug", S_IRUGO | S_IFREG, NULL,
				NULL, &dm3730logic_cf_debug_fops);
#endif

	pr_info("omap-cf: registering platform binding\n");
	rc = platform_driver_register(&dm3730logic_cf_platform_driver);
	if (rc)
		goto err_plat;

	printk(KERN_INFO "DM3730 SOM LV memory CompactFlash device driver, major=%i\n", cf_major);

	return 0;

err_plat:
	unregister_blkdev(cf_major, "dm3730logic-cf");
err_blk:
	printk(KERN_ERR "omap-cf: registration failed; err=%i\n", rc);
	return rc;
}