[PATCH] uml ubd driver: var renames (7d314e34) · Commits · e / devices / android_kernel_fairphone_FP3

arch/um/drivers/ubd_kern.c

+98 −98

Original line number	Original line	Diff line number	Diff line
	@@ -195,14 +195,14 @@ struct ubd {
	.cow = DEFAULT_COW, \		.cow = DEFAULT_COW, \
	}		}

	struct ubd ubd_dev[MAX_DEV] = { [ 0 ... MAX_DEV - 1 ] = DEFAULT_UBD };		struct ubd ubd_devs[MAX_DEV] = { [ 0 ... MAX_DEV - 1 ] = DEFAULT_UBD };

	static int ubd0_init(void)		static int ubd0_init(void)
	{		{
	struct ubd *dev = &ubd_dev[0];		struct ubd *ubd_dev = &ubd_devs[0];

	if(dev->file == NULL)		if(ubd_dev->file == NULL)
	dev->file = "root_fs";		ubd_dev->file = "root_fs";
	return(0);		return(0);
	}		}

	@@ -290,7 +290,7 @@ static int parse_unit(char **ptr)

	static int ubd_setup_common(char str, int index_out)		static int ubd_setup_common(char str, int index_out)
	{		{
	struct ubd *dev;		struct ubd *ubd_dev;
	struct openflags flags = global_openflags;		struct openflags flags = global_openflags;
	char *backing_file;		char *backing_file;
	int n, err, i;		int n, err, i;
	@@ -345,8 +345,8 @@ static int ubd_setup_common(char str, int index_out)
	err = 1;		err = 1;
	spin_lock(&ubd_lock);		spin_lock(&ubd_lock);

	dev = &ubd_dev[n];		ubd_dev = &ubd_devs[n];
	if(dev->file != NULL){		if(ubd_dev->file != NULL){
	printk(KERN_ERR "ubd_setup : device already configured\n");		printk(KERN_ERR "ubd_setup : device already configured\n");
	goto out;		goto out;
	}		}
	@@ -363,10 +363,10 @@ static int ubd_setup_common(char str, int index_out)
	flags.s = 1;		flags.s = 1;
	break;		break;
	case 'd':		case 'd':
	dev->no_cow = 1;		ubd_dev->no_cow = 1;
	break;		break;
	case 'c':		case 'c':
	dev->shared = 1;		ubd_dev->shared = 1;
	break;		break;
	case '=':		case '=':
	str++;		str++;
	@@ -393,7 +393,7 @@ static int ubd_setup_common(char str, int index_out)
	}		}

	if(backing_file){		if(backing_file){
	if(dev->no_cow)		if(ubd_dev->no_cow)
	printk(KERN_ERR "Can't specify both 'd' and a "		printk(KERN_ERR "Can't specify both 'd' and a "
	"cow file\n");		"cow file\n");
	else {		else {
	@@ -401,9 +401,9 @@ static int ubd_setup_common(char str, int index_out)
	backing_file++;		backing_file++;
	}		}
	}		}
	dev->file = str;		ubd_dev->file = str;
	dev->cow.file = backing_file;		ubd_dev->cow.file = backing_file;
	dev->boot_openflags = flags;		ubd_dev->boot_openflags = flags;
	out:		out:
	spin_unlock(&ubd_lock);		spin_unlock(&ubd_lock);
	return(err);		return(err);
	@@ -544,83 +544,83 @@ void kill_io_thread(void)

	__uml_exitcall(kill_io_thread);		__uml_exitcall(kill_io_thread);

	static int ubd_file_size(struct ubd dev, __u64 size_out)		static int ubd_file_size(struct ubd ubd_dev, __u64 size_out)
	{		{
	char *file;		char *file;

	file = dev->cow.file ? dev->cow.file : dev->file;		file = ubd_dev->cow.file ? ubd_dev->cow.file : ubd_dev->file;
	return(os_file_size(file, size_out));		return(os_file_size(file, size_out));
	}		}

	static void ubd_close(struct ubd *dev)		static void ubd_close(struct ubd *ubd_dev)
	{		{
	os_close_file(dev->fd);		os_close_file(ubd_dev->fd);
	if(dev->cow.file == NULL)		if(ubd_dev->cow.file == NULL)
	return;		return;

	os_close_file(dev->cow.fd);		os_close_file(ubd_dev->cow.fd);
	vfree(dev->cow.bitmap);		vfree(ubd_dev->cow.bitmap);
	dev->cow.bitmap = NULL;		ubd_dev->cow.bitmap = NULL;
	}		}

	static int ubd_open_dev(struct ubd *dev)		static int ubd_open_dev(struct ubd *ubd_dev)
	{		{
	struct openflags flags;		struct openflags flags;
	char **back_ptr;		char **back_ptr;
	int err, create_cow, *create_ptr;		int err, create_cow, *create_ptr;

	dev->openflags = dev->boot_openflags;		ubd_dev->openflags = ubd_dev->boot_openflags;
	create_cow = 0;		create_cow = 0;
	create_ptr = (dev->cow.file != NULL) ? &create_cow : NULL;		create_ptr = (ubd_dev->cow.file != NULL) ? &create_cow : NULL;
	back_ptr = dev->no_cow ? NULL : &dev->cow.file;		back_ptr = ubd_dev->no_cow ? NULL : &ubd_dev->cow.file;
	dev->fd = open_ubd_file(dev->file, &dev->openflags, dev->shared,		ubd_dev->fd = open_ubd_file(ubd_dev->file, &ubd_dev->openflags, ubd_dev->shared,
	back_ptr, &dev->cow.bitmap_offset,		back_ptr, &ubd_dev->cow.bitmap_offset,
	&dev->cow.bitmap_len, &dev->cow.data_offset,		&ubd_dev->cow.bitmap_len, &ubd_dev->cow.data_offset,
	create_ptr);		create_ptr);

	if((dev->fd == -ENOENT) && create_cow){		if((ubd_dev->fd == -ENOENT) && create_cow){
	dev->fd = create_cow_file(dev->file, dev->cow.file,		ubd_dev->fd = create_cow_file(ubd_dev->file, ubd_dev->cow.file,
	dev->openflags, 1 << 9, PAGE_SIZE,		ubd_dev->openflags, 1 << 9, PAGE_SIZE,
	&dev->cow.bitmap_offset,		&ubd_dev->cow.bitmap_offset,
	&dev->cow.bitmap_len,		&ubd_dev->cow.bitmap_len,
	&dev->cow.data_offset);		&ubd_dev->cow.data_offset);
	if(dev->fd >= 0){		if(ubd_dev->fd >= 0){
	printk(KERN_INFO "Creating \"%s\" as COW file for "		printk(KERN_INFO "Creating \"%s\" as COW file for "
	"\"%s\"\n", dev->file, dev->cow.file);		"\"%s\"\n", ubd_dev->file, ubd_dev->cow.file);
	}		}
	}		}

	if(dev->fd < 0){		if(ubd_dev->fd < 0){
	printk("Failed to open '%s', errno = %d\n", dev->file,		printk("Failed to open '%s', errno = %d\n", ubd_dev->file,
	-dev->fd);		-ubd_dev->fd);
	return(dev->fd);		return(ubd_dev->fd);
	}		}

	if(dev->cow.file != NULL){		if(ubd_dev->cow.file != NULL){
	err = -ENOMEM;		err = -ENOMEM;
	dev->cow.bitmap = (void *) vmalloc(dev->cow.bitmap_len);		ubd_dev->cow.bitmap = (void *) vmalloc(ubd_dev->cow.bitmap_len);
	if(dev->cow.bitmap == NULL){		if(ubd_dev->cow.bitmap == NULL){
	printk(KERN_ERR "Failed to vmalloc COW bitmap\n");		printk(KERN_ERR "Failed to vmalloc COW bitmap\n");
	goto error;		goto error;
	}		}
	flush_tlb_kernel_vm();		flush_tlb_kernel_vm();

	err = read_cow_bitmap(dev->fd, dev->cow.bitmap,		err = read_cow_bitmap(ubd_dev->fd, ubd_dev->cow.bitmap,
	dev->cow.bitmap_offset,		ubd_dev->cow.bitmap_offset,
	dev->cow.bitmap_len);		ubd_dev->cow.bitmap_len);
	if(err < 0)		if(err < 0)
	goto error;		goto error;

	flags = dev->openflags;		flags = ubd_dev->openflags;
	flags.w = 0;		flags.w = 0;
	err = open_ubd_file(dev->cow.file, &flags, dev->shared, NULL,		err = open_ubd_file(ubd_dev->cow.file, &flags, ubd_dev->shared, NULL,
	NULL, NULL, NULL, NULL);		NULL, NULL, NULL, NULL);
	if(err < 0) goto error;		if(err < 0) goto error;
	dev->cow.fd = err;		ubd_dev->cow.fd = err;
	}		}
	return(0);		return(0);
	error:		error:
	os_close_file(dev->fd);		os_close_file(ubd_dev->fd);
	return(err);		return(err);
	}		}

	@@ -645,13 +645,13 @@ static int ubd_new_disk(int major, u64 size, int unit,

	/* sysfs register (not for ide fake devices) */		/* sysfs register (not for ide fake devices) */
	if (major == MAJOR_NR) {		if (major == MAJOR_NR) {
	ubd_dev[unit].pdev.id = unit;		ubd_devs[unit].pdev.id = unit;
	ubd_dev[unit].pdev.name = DRIVER_NAME;		ubd_devs[unit].pdev.name = DRIVER_NAME;
	platform_device_register(&ubd_dev[unit].pdev);		platform_device_register(&ubd_devs[unit].pdev);
	disk->driverfs_dev = &ubd_dev[unit].pdev.dev;		disk->driverfs_dev = &ubd_devs[unit].pdev.dev;
	}		}

	disk->private_data = &ubd_dev[unit];		disk->private_data = &ubd_devs[unit];
	disk->queue = ubd_queue;		disk->queue = ubd_queue;
	add_disk(disk);		add_disk(disk);

	@@ -663,25 +663,25 @@ static int ubd_new_disk(int major, u64 size, int unit,

	static int ubd_add(int n)		static int ubd_add(int n)
	{		{
	struct ubd *dev = &ubd_dev[n];		struct ubd *ubd_dev = &ubd_devs[n];
	int err;		int err;

	err = -ENODEV;		err = -ENODEV;
	if(dev->file == NULL)		if(ubd_dev->file == NULL)
	goto out;		goto out;

	err = ubd_file_size(dev, &dev->size);		err = ubd_file_size(ubd_dev, &ubd_dev->size);
	if(err < 0)		if(err < 0)
	goto out;		goto out;

	dev->size = ROUND_BLOCK(dev->size);		ubd_dev->size = ROUND_BLOCK(ubd_dev->size);

	err = ubd_new_disk(MAJOR_NR, dev->size, n, &ubd_gendisk[n]);		err = ubd_new_disk(MAJOR_NR, ubd_dev->size, n, &ubd_gendisk[n]);
	if(err)		if(err)
	goto out;		goto out;

	if(fake_major != MAJOR_NR)		if(fake_major != MAJOR_NR)
	ubd_new_disk(fake_major, dev->size, n,		ubd_new_disk(fake_major, ubd_dev->size, n,
	&fake_gendisk[n]);		&fake_gendisk[n]);

	/* perhaps this should also be under the "if (fake_major)" above */		/* perhaps this should also be under the "if (fake_major)" above */
	@@ -713,7 +713,7 @@ static int ubd_config(char *str)
	spin_lock(&ubd_lock);		spin_lock(&ubd_lock);
	err = ubd_add(n);		err = ubd_add(n);
	if(err)		if(err)
	ubd_dev[n].file = NULL;		ubd_devs[n].file = NULL;
	spin_unlock(&ubd_lock);		spin_unlock(&ubd_lock);

	return(err);		return(err);
	@@ -721,7 +721,7 @@ static int ubd_config(char *str)

	static int ubd_get_config(char name, char str, int size, char **error_out)		static int ubd_get_config(char name, char str, int size, char **error_out)
	{		{
	struct ubd *dev;		struct ubd *ubd_dev;
	int n, len = 0;		int n, len = 0;

	n = parse_unit(&name);		n = parse_unit(&name);
	@@ -730,19 +730,19 @@ static int ubd_get_config(char name, char str, int size, char **error_out)
	return(-1);		return(-1);
	}		}

	dev = &ubd_dev[n];		ubd_dev = &ubd_devs[n];
	spin_lock(&ubd_lock);		spin_lock(&ubd_lock);

	if(dev->file == NULL){		if(ubd_dev->file == NULL){
	CONFIG_CHUNK(str, size, len, "", 1);		CONFIG_CHUNK(str, size, len, "", 1);
	goto out;		goto out;
	}		}

	CONFIG_CHUNK(str, size, len, dev->file, 0);		CONFIG_CHUNK(str, size, len, ubd_dev->file, 0);

	if(dev->cow.file != NULL){		if(ubd_dev->cow.file != NULL){
	CONFIG_CHUNK(str, size, len, ",", 0);		CONFIG_CHUNK(str, size, len, ",", 0);
	CONFIG_CHUNK(str, size, len, dev->cow.file, 1);		CONFIG_CHUNK(str, size, len, ubd_dev->cow.file, 1);
	}		}
	else CONFIG_CHUNK(str, size, len, "", 1);		else CONFIG_CHUNK(str, size, len, "", 1);

	@@ -763,7 +763,7 @@ static int ubd_id(char *str, int start_out, int *end_out)

	static int ubd_remove(int n)		static int ubd_remove(int n)
	{		{
	struct ubd *dev;		struct ubd *ubd_dev;
	int err = -ENODEV;		int err = -ENODEV;

	spin_lock(&ubd_lock);		spin_lock(&ubd_lock);
	@@ -771,14 +771,14 @@ static int ubd_remove(int n)
	if(ubd_gendisk[n] == NULL)		if(ubd_gendisk[n] == NULL)
	goto out;		goto out;

	dev = &ubd_dev[n];		ubd_dev = &ubd_devs[n];

	if(dev->file == NULL)		if(ubd_dev->file == NULL)
	goto out;		goto out;

	/* you cannot remove a open disk */		/* you cannot remove a open disk */
	err = -EBUSY;		err = -EBUSY;
	if(dev->count > 0)		if(ubd_dev->count > 0)
	goto out;		goto out;

	del_gendisk(ubd_gendisk[n]);		del_gendisk(ubd_gendisk[n]);
	@@ -791,8 +791,8 @@ static int ubd_remove(int n)
	fake_gendisk[n] = NULL;		fake_gendisk[n] = NULL;
	}		}

	platform_device_unregister(&dev->pdev);		platform_device_unregister(&ubd_dev->pdev);
	*dev = ((struct ubd) DEFAULT_UBD);		*ubd_dev = ((struct ubd) DEFAULT_UBD);
	err = 0;		err = 0;
	out:		out:
	spin_unlock(&ubd_lock);		spin_unlock(&ubd_lock);
	@@ -870,7 +870,7 @@ int ubd_driver_init(void){
	return(0);		return(0);
	}		}
	err = um_request_irq(UBD_IRQ, thread_fd, IRQ_READ, ubd_intr,		err = um_request_irq(UBD_IRQ, thread_fd, IRQ_READ, ubd_intr,
	IRQF_DISABLED, "ubd", ubd_dev);		IRQF_DISABLED, "ubd", ubd_devs);
	if(err != 0)		if(err != 0)
	printk(KERN_ERR "um_request_irq failed - errno = %d\n", -err);		printk(KERN_ERR "um_request_irq failed - errno = %d\n", -err);
	return 0;		return 0;
	@@ -881,24 +881,24 @@ device_initcall(ubd_driver_init);
	static int ubd_open(struct inode inode, struct file filp)		static int ubd_open(struct inode inode, struct file filp)
	{		{
	struct gendisk *disk = inode->i_bdev->bd_disk;		struct gendisk *disk = inode->i_bdev->bd_disk;
	struct ubd *dev = disk->private_data;		struct ubd *ubd_dev = disk->private_data;
	int err = 0;		int err = 0;

	if(dev->count == 0){		if(ubd_dev->count == 0){
	err = ubd_open_dev(dev);		err = ubd_open_dev(ubd_dev);
	if(err){		if(err){
	printk(KERN_ERR "%s: Can't open \"%s\": errno = %d\n",		printk(KERN_ERR "%s: Can't open \"%s\": errno = %d\n",
	disk->disk_name, dev->file, -err);		disk->disk_name, ubd_dev->file, -err);
	goto out;		goto out;
	}		}
	}		}
	dev->count++;		ubd_dev->count++;
	set_disk_ro(disk, !dev->openflags.w);		set_disk_ro(disk, !ubd_dev->openflags.w);

	/* This should no more be needed. And it didn't work anyway to exclude		/* This should no more be needed. And it didn't work anyway to exclude
	* read-write remounting of filesystems.*/		* read-write remounting of filesystems.*/
	/*if((filp->f_mode & FMODE_WRITE) && !dev->openflags.w){		/*if((filp->f_mode & FMODE_WRITE) && !ubd_dev->openflags.w){
	if(--dev->count == 0) ubd_close(dev);		if(--ubd_dev->count == 0) ubd_close(ubd_dev);
	err = -EROFS;		err = -EROFS;
	}*/		}*/
	out:		out:
	@@ -908,10 +908,10 @@ static int ubd_open(struct inode inode, struct file filp)
	static int ubd_release(struct inode * inode, struct file * file)		static int ubd_release(struct inode * inode, struct file * file)
	{		{
	struct gendisk *disk = inode->i_bdev->bd_disk;		struct gendisk *disk = inode->i_bdev->bd_disk;
	struct ubd *dev = disk->private_data;		struct ubd *ubd_dev = disk->private_data;

	if(--dev->count == 0)		if(--ubd_dev->count == 0)
	ubd_close(dev);		ubd_close(ubd_dev);
	return(0);		return(0);
	}		}

	@@ -979,12 +979,12 @@ static void cowify_req(struct io_thread_req req, unsigned long bitmap,
	static int prepare_request(struct request req, struct io_thread_req io_req)		static int prepare_request(struct request req, struct io_thread_req io_req)
	{		{
	struct gendisk *disk = req->rq_disk;		struct gendisk *disk = req->rq_disk;
	struct ubd *dev = disk->private_data;		struct ubd *ubd_dev = disk->private_data;
	__u64 offset;		__u64 offset;
	int len;		int len;

	/* This should be impossible now */		/* This should be impossible now */
	if((rq_data_dir(req) == WRITE) && !dev->openflags.w){		if((rq_data_dir(req) == WRITE) && !ubd_dev->openflags.w){
	printk("Write attempted on readonly ubd device %s\n",		printk("Write attempted on readonly ubd device %s\n",
	disk->disk_name);		disk->disk_name);
	end_request(req, 0);		end_request(req, 0);
	@@ -994,8 +994,8 @@ static int prepare_request(struct request req, struct io_thread_req io_req)
	offset = ((__u64) req->sector) << 9;		offset = ((__u64) req->sector) << 9;
	len = req->current_nr_sectors << 9;		len = req->current_nr_sectors << 9;

	io_req->fds[0] = (dev->cow.file != NULL) ? dev->cow.fd : dev->fd;		io_req->fds[0] = (ubd_dev->cow.file != NULL) ? ubd_dev->cow.fd : ubd_dev->fd;
	io_req->fds[1] = dev->fd;		io_req->fds[1] = ubd_dev->fd;
	io_req->cow_offset = -1;		io_req->cow_offset = -1;
	io_req->offset = offset;		io_req->offset = offset;
	io_req->length = len;		io_req->length = len;
	@@ -1004,13 +1004,13 @@ static int prepare_request(struct request req, struct io_thread_req io_req)

	io_req->op = (rq_data_dir(req) == READ) ? UBD_READ : UBD_WRITE;		io_req->op = (rq_data_dir(req) == READ) ? UBD_READ : UBD_WRITE;
	io_req->offsets[0] = 0;		io_req->offsets[0] = 0;
	io_req->offsets[1] = dev->cow.data_offset;		io_req->offsets[1] = ubd_dev->cow.data_offset;
	io_req->buffer = req->buffer;		io_req->buffer = req->buffer;
	io_req->sectorsize = 1 << 9;		io_req->sectorsize = 1 << 9;

	if(dev->cow.file != NULL)		if(ubd_dev->cow.file != NULL)
	cowify_req(io_req, dev->cow.bitmap, dev->cow.bitmap_offset,		cowify_req(io_req, ubd_dev->cow.bitmap, ubd_dev->cow.bitmap_offset,
	dev->cow.bitmap_len);		ubd_dev->cow.bitmap_len);

	return(0);		return(0);
	}		}
	@@ -1048,18 +1048,18 @@ static void do_ubd_request(request_queue_t *q)

	static int ubd_getgeo(struct block_device bdev, struct hd_geometry geo)		static int ubd_getgeo(struct block_device bdev, struct hd_geometry geo)
	{		{
	struct ubd *dev = bdev->bd_disk->private_data;		struct ubd *ubd_dev = bdev->bd_disk->private_data;

	geo->heads = 128;		geo->heads = 128;
	geo->sectors = 32;		geo->sectors = 32;
	geo->cylinders = dev->size / (128 * 32 * 512);		geo->cylinders = ubd_dev->size / (128 * 32 * 512);
	return 0;		return 0;
	}		}

	static int ubd_ioctl(struct inode * inode, struct file * file,		static int ubd_ioctl(struct inode * inode, struct file * file,
	unsigned int cmd, unsigned long arg)		unsigned int cmd, unsigned long arg)
	{		{
	struct ubd *dev = inode->i_bdev->bd_disk->private_data;		struct ubd *ubd_dev = inode->i_bdev->bd_disk->private_data;
	struct hd_driveid ubd_id = {		struct hd_driveid ubd_id = {
	.cyls = 0,		.cyls = 0,
	.heads = 128,		.heads = 128,
	@@ -1069,7 +1069,7 @@ static int ubd_ioctl(struct inode * inode, struct file * file,
	switch (cmd) {		switch (cmd) {
	struct cdrom_volctrl volume;		struct cdrom_volctrl volume;
	case HDIO_GET_IDENTITY:		case HDIO_GET_IDENTITY:
	ubd_id.cyls = dev->size / (128 * 32 * 512);		ubd_id.cyls = ubd_dev->size / (128 * 32 * 512);
	if(copy_to_user((char __user ) arg, (char ) &ubd_id,		if(copy_to_user((char __user ) arg, (char ) &ubd_id,
	sizeof(ubd_id)))		sizeof(ubd_id)))
	return(-EFAULT);		return(-EFAULT);