OpenE2K
/
linux
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[PATCH] uml ubd driver: var renames 

Rename the ubd_dev array to ubd_devs and then call any "struct ubd" ubd_dev
instead of dev, which doesn't make clear what we're treating (and no, it's not
hungarian notation - not any more than calling all vm_area_struct vma or all
inodes inode).

Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
This commit is contained in:
Paolo 'Blaisorblade' Giarrusso 2006-10-30 22:07:05 -08:00 committed by Linus Torvalds
parent 2a9d32f682
commit 7d314e346d
1 changed files with 98 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

196
arch/um/drivers/ubd_kern.c
View File

@ -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 @@ break_loop:
} }
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 @@ break_loop:
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);