Driver core: convert block from raw kobjects to core devices
[linux-2.6.git] / drivers / block / nbd.c
index c575fb1..ba9b17e 100644 (file)
@@ -28,6 +28,7 @@
 #include <linux/err.h>
 #include <linux/kernel.h>
 #include <net/sock.h>
+#include <linux/net.h>
 
 #include <asm/uaccess.h>
 #include <asm/system.h>
@@ -100,7 +101,7 @@ static const char *nbdcmd_to_ascii(int cmd)
 static void nbd_end_request(struct request *req)
 {
        int uptodate = (req->errors == 0) ? 1 : 0;
-       request_queue_t *q = req->q;
+       struct request_queue *q = req->q;
        unsigned long flags;
 
        dprintk(DBG_BLKDEV, "%s: request %p: %s\n", req->rq_disk->disk_name,
@@ -113,26 +114,51 @@ static void nbd_end_request(struct request *req)
        spin_unlock_irqrestore(q->queue_lock, flags);
 }
 
+static void sock_shutdown(struct nbd_device *lo, int lock)
+{
+       /* Forcibly shutdown the socket causing all listeners
+        * to error
+        *
+        * FIXME: This code is duplicated from sys_shutdown, but
+        * there should be a more generic interface rather than
+        * calling socket ops directly here */
+       if (lock)
+               mutex_lock(&lo->tx_lock);
+       if (lo->sock) {
+               printk(KERN_WARNING "%s: shutting down socket\n",
+                       lo->disk->disk_name);
+               kernel_sock_shutdown(lo->sock, SHUT_RDWR);
+               lo->sock = NULL;
+       }
+       if (lock)
+               mutex_unlock(&lo->tx_lock);
+}
+
+static void nbd_xmit_timeout(unsigned long arg)
+{
+       struct task_struct *task = (struct task_struct *)arg;
+
+       printk(KERN_WARNING "nbd: killing hung xmit (%s, pid: %d)\n",
+               task->comm, task->pid);
+       force_sig(SIGKILL, task);
+}
+
 /*
  *  Send or receive packet.
  */
-static int sock_xmit(struct socket *sock, int send, void *buf, int size,
+static int sock_xmit(struct nbd_device *lo, int send, void *buf, int size,
                int msg_flags)
 {
+       struct socket *sock = lo->sock;
        int result;
        struct msghdr msg;
        struct kvec iov;
-       unsigned long flags;
-       sigset_t oldset;
+       sigset_t blocked, oldset;
 
        /* Allow interception of SIGKILL only
         * Don't allow other signals to interrupt the transmission */
-       spin_lock_irqsave(&current->sighand->siglock, flags);
-       oldset = current->blocked;
-       sigfillset(&current->blocked);
-       sigdelsetmask(&current->blocked, sigmask(SIGKILL));
-       recalc_sigpending();
-       spin_unlock_irqrestore(&current->sighand->siglock, flags);
+       siginitsetinv(&blocked, sigmask(SIGKILL));
+       sigprocmask(SIG_SETMASK, &blocked, &oldset);
 
        do {
                sock->sk->sk_allocation = GFP_NOIO;
@@ -144,19 +170,29 @@ static int sock_xmit(struct socket *sock, int send, void *buf, int size,
                msg.msg_controllen = 0;
                msg.msg_flags = msg_flags | MSG_NOSIGNAL;
 
-               if (send)
+               if (send) {
+                       struct timer_list ti;
+
+                       if (lo->xmit_timeout) {
+                               init_timer(&ti);
+                               ti.function = nbd_xmit_timeout;
+                               ti.data = (unsigned long)current;
+                               ti.expires = jiffies + lo->xmit_timeout;
+                               add_timer(&ti);
+                       }
                        result = kernel_sendmsg(sock, &msg, &iov, 1, size);
-               else
+                       if (lo->xmit_timeout)
+                               del_timer_sync(&ti);
+               } else
                        result = kernel_recvmsg(sock, &msg, &iov, 1, size, 0);
 
                if (signal_pending(current)) {
                        siginfo_t info;
-                       spin_lock_irqsave(&current->sighand->siglock, flags);
                        printk(KERN_WARNING "nbd (pid %d: %s) got signal %d\n",
-                               current->pid, current->comm, 
-                               dequeue_signal(current, &current->blocked, &info));
-                       spin_unlock_irqrestore(&current->sighand->siglock, flags);
+                               task_pid_nr(current), current->comm,
+                               dequeue_signal_lock(current, &current->blocked, &info));
                        result = -EINTR;
+                       sock_shutdown(lo, !send);
                        break;
                }
 
@@ -169,31 +205,27 @@ static int sock_xmit(struct socket *sock, int send, void *buf, int size,
                buf += result;
        } while (size > 0);
 
-       spin_lock_irqsave(&current->sighand->siglock, flags);
-       current->blocked = oldset;
-       recalc_sigpending();
-       spin_unlock_irqrestore(&current->sighand->siglock, flags);
+       sigprocmask(SIG_SETMASK, &oldset, NULL);
 
        return result;
 }
 
-static inline int sock_send_bvec(struct socket *sock, struct bio_vec *bvec,
+static inline int sock_send_bvec(struct nbd_device *lo, struct bio_vec *bvec,
                int flags)
 {
        int result;
        void *kaddr = kmap(bvec->bv_page);
-       result = sock_xmit(sock, 1, kaddr + bvec->bv_offset, bvec->bv_len,
-                       flags);
+       result = sock_xmit(lo, 1, kaddr + bvec->bv_offset, bvec->bv_len, flags);
        kunmap(bvec->bv_page);
        return result;
 }
 
+/* always call with the tx_lock held */
 static int nbd_send_req(struct nbd_device *lo, struct request *req)
 {
-       int result, i, flags;
+       int result, flags;
        struct nbd_request request;
        unsigned long size = req->nr_sectors << 9;
-       struct socket *sock = lo->sock;
 
        request.magic = htonl(NBD_REQUEST_MAGIC);
        request.type = htonl(nbd_cmd(req));
@@ -206,8 +238,8 @@ static int nbd_send_req(struct nbd_device *lo, struct request *req)
                        nbdcmd_to_ascii(nbd_cmd(req)),
                        (unsigned long long)req->sector << 9,
                        req->nr_sectors << 9);
-       result = sock_xmit(sock, 1, &request, sizeof(request),
-                       (nbd_cmd(req) == NBD_CMD_WRITE)? MSG_MORE: 0);
+       result = sock_xmit(lo, 1, &request, sizeof(request),
+                       (nbd_cmd(req) == NBD_CMD_WRITE) ? MSG_MORE : 0);
        if (result <= 0) {
                printk(KERN_ERR "%s: Send control failed (result %d)\n",
                                lo->disk->disk_name, result);
@@ -215,27 +247,23 @@ static int nbd_send_req(struct nbd_device *lo, struct request *req)
        }
 
        if (nbd_cmd(req) == NBD_CMD_WRITE) {
-               struct bio *bio;
+               struct req_iterator iter;
+               struct bio_vec *bvec;
                /*
                 * we are really probing at internals to determine
                 * whether to set MSG_MORE or not...
                 */
-               rq_for_each_bio(bio, req) {
-                       struct bio_vec *bvec;
-                       bio_for_each_segment(bvec, bio, i) {
-                               flags = 0;
-                               if ((i < (bio->bi_vcnt - 1)) || bio->bi_next)
-                                       flags = MSG_MORE;
-                               dprintk(DBG_TX, "%s: request %p: sending %d bytes data\n",
-                                               lo->disk->disk_name, req,
-                                               bvec->bv_len);
-                               result = sock_send_bvec(sock, bvec, flags);
-                               if (result <= 0) {
-                                       printk(KERN_ERR "%s: Send data failed (result %d)\n",
-                                                       lo->disk->disk_name,
-                                                       result);
-                                       goto error_out;
-                               }
+               rq_for_each_segment(bvec, req, iter) {
+                       flags = 0;
+                       if (!rq_iter_last(req, iter))
+                               flags = MSG_MORE;
+                       dprintk(DBG_TX, "%s: request %p: sending %d bytes data\n",
+                                       lo->disk->disk_name, req, bvec->bv_len);
+                       result = sock_send_bvec(lo, bvec, flags);
+                       if (result <= 0) {
+                               printk(KERN_ERR "%s: Send data failed (result %d)\n",
+                                               lo->disk->disk_name, result);
+                               goto error_out;
                        }
                }
        }
@@ -245,22 +273,18 @@ error_out:
        return 1;
 }
 
-static struct request *nbd_find_request(struct nbd_device *lo, char *handle)
+static struct request *nbd_find_request(struct nbd_device *lo,
+                                       struct request *xreq)
 {
-       struct request *req;
-       struct list_head *tmp;
-       struct request *xreq;
+       struct request *req, *tmp;
        int err;
 
-       memcpy(&xreq, handle, sizeof(xreq));
-
        err = wait_event_interruptible(lo->active_wq, lo->active_req != xreq);
        if (unlikely(err))
                goto out;
 
        spin_lock(&lo->queue_lock);
-       list_for_each(tmp, &lo->queue_head) {
-               req = list_entry(tmp, struct request, queuelist);
+       list_for_each_entry_safe(req, tmp, &lo->queue_head, queuelist) {
                if (req != xreq)
                        continue;
                list_del_init(&req->queuelist);
@@ -275,11 +299,11 @@ out:
        return ERR_PTR(err);
 }
 
-static inline int sock_recv_bvec(struct socket *sock, struct bio_vec *bvec)
+static inline int sock_recv_bvec(struct nbd_device *lo, struct bio_vec *bvec)
 {
        int result;
        void *kaddr = kmap(bvec->bv_page);
-       result = sock_xmit(sock, 0, kaddr + bvec->bv_offset, bvec->bv_len,
+       result = sock_xmit(lo, 0, kaddr + bvec->bv_offset, bvec->bv_len,
                        MSG_WAITALL);
        kunmap(bvec->bv_page);
        return result;
@@ -291,10 +315,9 @@ static struct request *nbd_read_stat(struct nbd_device *lo)
        int result;
        struct nbd_reply reply;
        struct request *req;
-       struct socket *sock = lo->sock;
 
        reply.magic = 0;
-       result = sock_xmit(sock, 0, &reply, sizeof(reply), MSG_WAITALL);
+       result = sock_xmit(lo, 0, &reply, sizeof(reply), MSG_WAITALL);
        if (result <= 0) {
                printk(KERN_ERR "%s: Receive control failed (result %d)\n",
                                lo->disk->disk_name, result);
@@ -309,7 +332,7 @@ static struct request *nbd_read_stat(struct nbd_device *lo)
                goto harderror;
        }
 
-       req = nbd_find_request(lo, reply.handle);
+       req = nbd_find_request(lo, *(struct request **)reply.handle);
        if (unlikely(IS_ERR(req))) {
                result = PTR_ERR(req);
                if (result != -ENOENT)
@@ -331,22 +354,19 @@ static struct request *nbd_read_stat(struct nbd_device *lo)
        dprintk(DBG_RX, "%s: request %p: got reply\n",
                        lo->disk->disk_name, req);
        if (nbd_cmd(req) == NBD_CMD_READ) {
-               int i;
-               struct bio *bio;
-               rq_for_each_bio(bio, req) {
-                       struct bio_vec *bvec;
-                       bio_for_each_segment(bvec, bio, i) {
-                               result = sock_recv_bvec(sock, bvec);
-                               if (result <= 0) {
-                                       printk(KERN_ERR "%s: Receive data failed (result %d)\n",
-                                                       lo->disk->disk_name,
-                                                       result);
-                                       req->errors++;
-                                       return req;
-                               }
-                               dprintk(DBG_RX, "%s: request %p: got %d bytes data\n",
-                                       lo->disk->disk_name, req, bvec->bv_len);
+               struct req_iterator iter;
+               struct bio_vec *bvec;
+
+               rq_for_each_segment(bvec, req, iter) {
+                       result = sock_recv_bvec(lo, bvec);
+                       if (result <= 0) {
+                               printk(KERN_ERR "%s: Receive data failed (result %d)\n",
+                                               lo->disk->disk_name, result);
+                               req->errors++;
+                               return req;
                        }
+                       dprintk(DBG_RX, "%s: request %p: got %d bytes data\n",
+                               lo->disk->disk_name, req, bvec->bv_len);
                }
        }
        return req;
@@ -355,14 +375,17 @@ harderror:
        return NULL;
 }
 
-static ssize_t pid_show(struct gendisk *disk, char *page)
+static ssize_t pid_show(struct device *dev,
+                       struct device_attribute *attr, char *buf)
 {
-       return sprintf(page, "%ld\n",
+       struct gendisk *disk = dev_to_disk(dev);
+
+       return sprintf(buf, "%ld\n",
                (long) ((struct nbd_device *)disk->private_data)->pid);
 }
 
-static struct disk_attribute pid_attr = {
-       .attr = { .name = "pid", .mode = S_IRUGO },
+static struct device_attribute pid_attr = {
+       .attr = { .name = "pid", .mode = S_IRUGO, .owner = THIS_MODULE },
        .show = pid_show,
 };
 
@@ -374,7 +397,7 @@ static int nbd_do_it(struct nbd_device *lo)
        BUG_ON(lo->magic != LO_MAGIC);
 
        lo->pid = current->pid;
-       ret = sysfs_create_file(&lo->disk->kobj, &pid_attr.attr);
+       ret = sysfs_create_file(&lo->disk->dev.kobj, &pid_attr.attr);
        if (ret) {
                printk(KERN_ERR "nbd: sysfs_create_file failed!");
                return ret;
@@ -383,7 +406,7 @@ static int nbd_do_it(struct nbd_device *lo)
        while ((req = nbd_read_stat(lo)) != NULL)
                nbd_end_request(req);
 
-       sysfs_remove_file(&lo->disk->kobj, &pid_attr.attr);
+       sysfs_remove_file(&lo->disk->dev.kobj, &pid_attr.attr);
        return 0;
 }
 
@@ -413,6 +436,7 @@ static void nbd_clear_que(struct nbd_device *lo)
        }
 }
 
+
 /*
  * We always wait for result of write, for now. It would be nice to make it optional
  * in future
@@ -420,7 +444,7 @@ static void nbd_clear_que(struct nbd_device *lo)
  *   { printk( "Warning: Ignoring result!\n"); nbd_end_request( req ); }
  */
 
-static void do_nbd_request(request_queue_t * q)
+static void do_nbd_request(struct request_queue * q)
 {
        struct request *req;
        
@@ -488,7 +512,6 @@ error_out:
                nbd_end_request(req);
                spin_lock(q->queue_lock);
        }
-       return;
 }
 
 static int nbd_ioctl(struct inode *inode, struct file *file,
@@ -521,7 +544,9 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
                sreq.nr_sectors = 0;
                 if (!lo->sock)
                        return -EINVAL;
+               mutex_lock(&lo->tx_lock);
                 nbd_send_req(lo, &sreq);
+               mutex_unlock(&lo->tx_lock);
                 return 0;
  
        case NBD_CLEAR_SOCK:
@@ -565,6 +590,9 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
                set_blocksize(inode->i_bdev, lo->blksize);
                set_capacity(lo->disk, lo->bytesize >> 9);
                return 0;
+       case NBD_SET_TIMEOUT:
+               lo->xmit_timeout = arg * HZ;
+               return 0;
        case NBD_SET_SIZE_BLOCKS:
                lo->bytesize = ((u64) arg) * lo->blksize;
                inode->i_bdev->bd_inode->i_size = lo->bytesize;
@@ -577,28 +605,16 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
                error = nbd_do_it(lo);
                if (error)
                        return error;
-               /* on return tidy up in case we have a signal */
-               /* Forcibly shutdown the socket causing all listeners
-                * to error
-                *
-                * FIXME: This code is duplicated from sys_shutdown, but
-                * there should be a more generic interface rather than
-                * calling socket ops directly here */
-               mutex_lock(&lo->tx_lock);
-               if (lo->sock) {
-                       printk(KERN_WARNING "%s: shutting down socket\n",
-                               lo->disk->disk_name);
-                       lo->sock->ops->shutdown(lo->sock,
-                               SEND_SHUTDOWN|RCV_SHUTDOWN);
-                       lo->sock = NULL;
-               }
-               mutex_unlock(&lo->tx_lock);
+               sock_shutdown(lo, 1);
                file = lo->file;
                lo->file = NULL;
                nbd_clear_que(lo);
                printk(KERN_WARNING "%s: queue cleared\n", lo->disk->disk_name);
                if (file)
                        fput(file);
+               lo->bytesize = 0;
+               inode->i_bdev->bd_inode->i_size = 0;
+               set_capacity(lo->disk, 0);
                return lo->harderror;
        case NBD_CLEAR_QUE:
                /*
@@ -676,14 +692,14 @@ static int __init nbd_init(void)
                mutex_init(&nbd_dev[i].tx_lock);
                init_waitqueue_head(&nbd_dev[i].active_wq);
                nbd_dev[i].blksize = 1024;
-               nbd_dev[i].bytesize = 0x7ffffc00ULL << 10; /* 2TB */
+               nbd_dev[i].bytesize = 0;
                disk->major = NBD_MAJOR;
                disk->first_minor = i;
                disk->fops = &nbd_fops;
                disk->private_data = &nbd_dev[i];
                disk->flags |= GENHD_FL_SUPPRESS_PARTITION_INFO;
                sprintf(disk->disk_name, "nbd%d", i);
-               set_capacity(disk, 0x7ffffc00ULL << 1); /* 2 TB */
+               set_capacity(disk, 0);
                add_disk(disk);
        }