uml: start fixing os_read_file and os_write_file

[powerpc.git] / arch / um / drivers / ubd_kern.c

diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c
index f98d26e..6d163c9 100644 (file)
--- a/arch/um/drivers/ubd_kern.c
+++ b/arch/um/drivers/ubd_kern.c
@@ -39,7 +39,6 @@
 #include "asm/irq.h"
 #include "asm/types.h"
 #include "asm/tlbflush.h"
-#include "user_util.h"
 #include "mem_user.h"
 #include "kern_util.h"
 #include "kern.h"
@@ -109,10 +108,6 @@ static inline void ubd_set_bit(__u64 bit, unsigned char *data)
 
 static DEFINE_MUTEX(ubd_lock);
 
-/* XXX - this made sense in 2.4 days, now it's only used as a boolean, and
- * probably it doesn't make sense even for that. */
-static int do_ubd;
-
 static int ubd_open(struct inode * inode, struct file * filp);
 static int ubd_release(struct inode * inode, struct file * file);
 static int ubd_ioctl(struct inode * inode, struct file * file,
@@ -169,6 +164,7 @@ struct ubd {
        struct platform_device pdev;
        struct request_queue *queue;
        spinlock_t lock;
+       int active;
 };
 
 #define DEFAULT_COW { \
@@ -190,6 +186,7 @@ struct ubd {
        .shared =               0, \
         .cow =                 DEFAULT_COW, \
        .lock =                 SPIN_LOCK_UNLOCKED,     \
+       .active =               0, \
 }
 
 /* Protected by ubd_lock */
@@ -507,8 +504,7 @@ static void ubd_handler(void)
        struct ubd *dev;
        int n;
 
-       do_ubd = 0;
-       n = os_read_file(thread_fd, &req, sizeof(req));
+       n = os_read_file_k(thread_fd, &req, sizeof(req));
        if(n != sizeof(req)){
                printk(KERN_ERR "Pid %d - spurious interrupt in ubd_handler, "
                       "err = %d\n", os_getpid(), -n);
@@ -517,6 +513,7 @@ static void ubd_handler(void)
 
        rq = req.req;
        dev = rq->rq_disk->private_data;
+       dev->active = 0;
 
        ubd_finish(rq, req.error);
        reactivate_fd(thread_fd, UBD_IRQ);
@@ -625,6 +622,14 @@ static int ubd_open_dev(struct ubd *ubd_dev)
        return(err);
 }
 
+static void ubd_device_release(struct device *dev)
+{
+       struct ubd *ubd_dev = dev->driver_data;
+
+       blk_cleanup_queue(ubd_dev->queue);
+       *ubd_dev = ((struct ubd) DEFAULT_UBD);
+}
+
 static int ubd_disk_register(int major, u64 size, int unit,
                             struct gendisk **disk_out)
 {
@@ -647,6 +652,8 @@ static int ubd_disk_register(int major, u64 size, int unit,
        if (major == MAJOR_NR) {
                ubd_devs[unit].pdev.id   = unit;
                ubd_devs[unit].pdev.name = DRIVER_NAME;
+               ubd_devs[unit].pdev.dev.release = ubd_device_release;
+               ubd_devs[unit].pdev.dev.driver_data = &ubd_devs[unit];
                platform_device_register(&ubd_devs[unit].pdev);
                disk->driverfs_dev = &ubd_devs[unit].pdev.dev;
        }
@@ -790,14 +797,12 @@ static int ubd_id(char **str, int *start_out, int *end_out)
 
 static int ubd_remove(int n, char **error_out)
 {
+       struct gendisk *disk = ubd_gendisk[n];
        struct ubd *ubd_dev;
        int err = -ENODEV;
 
        mutex_lock(&ubd_lock);
 
-       if(ubd_gendisk[n] == NULL)
-               goto out;
-
        ubd_dev = &ubd_devs[n];
 
        if(ubd_dev->file == NULL)
@@ -808,9 +813,11 @@ static int ubd_remove(int n, char **error_out)
        if(ubd_dev->count > 0)
                goto out;
 
-       del_gendisk(ubd_gendisk[n]);
-       put_disk(ubd_gendisk[n]);
-       ubd_gendisk[n] = NULL;
+       ubd_gendisk[n] = NULL;
+       if(disk != NULL){
+               del_gendisk(disk);
+               put_disk(disk);
+       }
 
        if(fake_gendisk[n] != NULL){
                del_gendisk(fake_gendisk[n]);
@@ -818,10 +825,8 @@ static int ubd_remove(int n, char **error_out)
                fake_gendisk[n] = NULL;
        }
 
-       blk_cleanup_queue(ubd_dev->queue);
-       platform_device_unregister(&ubd_dev->pdev);
-       *ubd_dev = ((struct ubd) DEFAULT_UBD);
        err = 0;
+       platform_device_unregister(&ubd_dev->pdev);
 out:
        mutex_unlock(&ubd_lock);
        return err;
@@ -1081,13 +1086,13 @@ static void do_ubd_request(request_queue_t *q)
                }
        }
        else {
-               if(do_ubd || (req = elv_next_request(q)) == NULL)
+               struct ubd *dev = q->queuedata;
+               if(dev->active || (req = elv_next_request(q)) == NULL)
                        return;
                err = prepare_request(req, &io_req);
                if(!err){
-                       do_ubd = 1;
-                       n = os_write_file(thread_fd, (char *) &io_req,
-                                        sizeof(io_req));
+                       dev->active = 1;
+                       n = os_write_file_k(thread_fd, &io_req, sizeof(io_req));
                        if(n != sizeof(io_req))
                                printk("write to io thread failed, "
                                       "errno = %d\n", -n);
@@ -1330,8 +1335,8 @@ static int update_bitmap(struct io_thread_req *req)
                return(1);
        }
 
-       n = os_write_file(req->fds[1], &req->bitmap_words,
-                         sizeof(req->bitmap_words));
+       n = os_write_file_k(req->fds[1], &req->bitmap_words,
+                           sizeof(req->bitmap_words));
        if(n != sizeof(req->bitmap_words)){
                printk("do_io - bitmap update failed, err = %d fd = %d\n", -n,
                       req->fds[1]);
@@ -1375,7 +1380,7 @@ void do_io(struct io_thread_req *req)
                        do {
                                buf = &buf[n];
                                len -= n;
-                               n = os_read_file(req->fds[bit], buf, len);
+                               n = os_read_file_k(req->fds[bit], buf, len);
                                if (n < 0) {
                                        printk("do_io - read failed, err = %d "
                                               "fd = %d\n", -n, req->fds[bit]);
@@ -1385,7 +1390,7 @@ void do_io(struct io_thread_req *req)
                        } while((n < len) && (n != 0));
                        if (n < len) memset(&buf[n], 0, len - n);
                } else {
-                       n = os_write_file(req->fds[bit], buf, len);
+                       n = os_write_file_k(req->fds[bit], buf, len);
                        if(n != len){
                                printk("do_io - write failed err = %d "
                                       "fd = %d\n", -n, req->fds[bit]);
@@ -1415,7 +1420,7 @@ int io_thread(void *arg)
 
        ignore_sigwinch_sig();
        while(1){
-               n = os_read_file(kernel_fd, &req, sizeof(req));
+               n = os_read_file_k(kernel_fd, &req, sizeof(req));
                if(n != sizeof(req)){
                        if(n < 0)
                                printk("io_thread - read failed, fd = %d, "
@@ -1428,7 +1433,7 @@ int io_thread(void *arg)
                }
                io_count++;
                do_io(&req);
-               n = os_write_file(kernel_fd, &req, sizeof(req));
+               n = os_write_file_k(kernel_fd, &req, sizeof(req));
                if(n != sizeof(req))
                        printk("io_thread - write failed, fd = %d, err = %d\n",
                               kernel_fd, -n);