Driver core: convert block from raw kobjects to core devices
[linux-2.6.git] / drivers / block / nbd.c
index 6997d8e..ba9b17e 100644 (file)
@@ -7,39 +7,9 @@
  * Copyright 1997-2000 Pavel Machek <pavel@ucw.cz>
  * Parts copyright 2001 Steven Whitehouse <steve@chygwyn.com>
  *
- * (part of code stolen from loop.c)
+ * This file is released under GPLv2 or later.
  *
- * 97-3-25 compiled 0-th version, not yet tested it 
- *   (it did not work, BTW) (later that day) HEY! it works!
- *   (bit later) hmm, not that much... 2:00am next day:
- *   yes, it works, but it gives something like 50kB/sec
- * 97-4-01 complete rewrite to make it possible for many requests at 
- *   once to be processed
- * 97-4-11 Making protocol independent of endianity etc.
- * 97-9-13 Cosmetic changes
- * 98-5-13 Attempt to make 64-bit-clean on 64-bit machines
- * 99-1-11 Attempt to make 64-bit-clean on 32-bit machines <ankry@mif.pg.gda.pl>
- * 01-2-27 Fix to store proper blockcount for kernel (calculated using
- *   BLOCK_SIZE_BITS, not device blocksize) <aga@permonline.ru>
- * 01-3-11 Make nbd work with new Linux block layer code. It now supports
- *   plugging like all the other block devices. Also added in MSG_MORE to
- *   reduce number of partial TCP segments sent. <steve@chygwyn.com>
- * 01-12-6 Fix deadlock condition by making queue locks independent of
- *   the transmit lock. <steve@chygwyn.com>
- * 02-10-11 Allow hung xmit to be aborted via SIGKILL & various fixes.
- *   <Paul.Clements@SteelEye.com> <James.Bottomley@SteelEye.com>
- * 03-06-22 Make nbd work with new linux 2.5 block layer design. This fixes
- *   memory corruption from module removal and possible memory corruption
- *   from sending/receiving disk data. <ldl@aros.net>
- * 03-06-23 Cosmetic changes. <ldl@aros.net>
- * 03-06-23 Enhance diagnostics support. <ldl@aros.net>
- * 03-06-24 Remove unneeded blksize_bits field from nbd_device struct.
- *   <ldl@aros.net>
- * 03-06-24 Cleanup PARANOIA usage & code. <ldl@aros.net>
- * 04-02-19 Remove PARANOIA, plus various cleanups (Paul Clements)
- * possible FIXME: make set_sock / set_blksize / set_size / do_it one syscall
- * why not: would need access_ok and friends, would share yet another
- *          structure with userland
+ * (part of code stolen from loop.c)
  */
 
 #include <linux/major.h>
@@ -58,8 +28,7 @@
 #include <linux/err.h>
 #include <linux/kernel.h>
 #include <net/sock.h>
-
-#include <linux/devfs_fs_kernel.h>
+#include <linux/net.h>
 
 #include <asm/uaccess.h>
 #include <asm/system.h>
@@ -82,9 +51,9 @@
 #define DBG_RX          0x0200
 #define DBG_TX          0x0400
 static unsigned int debugflags;
-static unsigned int nbds_max = 16;
 #endif /* NDEBUG */
 
+static unsigned int nbds_max = 16;
 static struct nbd_device nbd_dev[MAX_NBD];
 
 /*
@@ -132,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,
@@ -145,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;
@@ -176,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;
                }
 
@@ -201,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));
@@ -238,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);
@@ -247,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;
                        }
                }
        }
@@ -277,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);
@@ -307,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;
@@ -323,16 +315,24 @@ 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);
                goto harderror;
        }
-       req = nbd_find_request(lo, reply.handle);
+
+       if (ntohl(reply.magic) != NBD_REPLY_MAGIC) {
+               printk(KERN_ERR "%s: Wrong magic (0x%lx)\n",
+                               lo->disk->disk_name,
+                               (unsigned long)ntohl(reply.magic));
+               result = -EPROTO;
+               goto harderror;
+       }
+
+       req = nbd_find_request(lo, *(struct request **)reply.handle);
        if (unlikely(IS_ERR(req))) {
                result = PTR_ERR(req);
                if (result != -ENOENT)
@@ -344,13 +344,6 @@ static struct request *nbd_read_stat(struct nbd_device *lo)
                goto harderror;
        }
 
-       if (ntohl(reply.magic) != NBD_REPLY_MAGIC) {
-               printk(KERN_ERR "%s: Wrong magic (0x%lx)\n",
-                               lo->disk->disk_name,
-                               (unsigned long)ntohl(reply.magic));
-               result = -EPROTO;
-               goto harderror;
-       }
        if (ntohl(reply.error)) {
                printk(KERN_ERR "%s: Other side returned error (%d)\n",
                                lo->disk->disk_name, ntohl(reply.error));
@@ -361,21 +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);
-                                       goto harderror;
-                               }
-                               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;
@@ -384,15 +375,39 @@ harderror:
        return NULL;
 }
 
-static void nbd_do_it(struct nbd_device *lo)
+static ssize_t pid_show(struct device *dev,
+                       struct device_attribute *attr, char *buf)
+{
+       struct gendisk *disk = dev_to_disk(dev);
+
+       return sprintf(buf, "%ld\n",
+               (long) ((struct nbd_device *)disk->private_data)->pid);
+}
+
+static struct device_attribute pid_attr = {
+       .attr = { .name = "pid", .mode = S_IRUGO, .owner = THIS_MODULE },
+       .show = pid_show,
+};
+
+static int nbd_do_it(struct nbd_device *lo)
 {
        struct request *req;
+       int ret;
 
        BUG_ON(lo->magic != LO_MAGIC);
 
+       lo->pid = current->pid;
+       ret = sysfs_create_file(&lo->disk->dev.kobj, &pid_attr.attr);
+       if (ret) {
+               printk(KERN_ERR "nbd: sysfs_create_file failed!");
+               return ret;
+       }
+
        while ((req = nbd_read_stat(lo)) != NULL)
                nbd_end_request(req);
-       return;
+
+       sysfs_remove_file(&lo->disk->dev.kobj, &pid_attr.attr);
+       return 0;
 }
 
 static void nbd_clear_que(struct nbd_device *lo)
@@ -421,14 +436,15 @@ 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
- * if ((req->cmd == WRITE) && (lo->flags & NBD_WRITE_NOCHK)) 
+ * if ((rq_data_dir(req) == WRITE) && (lo->flags & NBD_WRITE_NOCHK))
  *   { 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;
        
@@ -436,10 +452,10 @@ static void do_nbd_request(request_queue_t * q)
                struct nbd_device *lo;
 
                blkdev_dequeue_request(req);
-               dprintk(DBG_BLKDEV, "%s: request %p: dequeued (flags=%lx)\n",
-                               req->rq_disk->disk_name, req, req->flags);
+               dprintk(DBG_BLKDEV, "%s: request %p: dequeued (flags=%x)\n",
+                               req->rq_disk->disk_name, req, req->cmd_type);
 
-               if (!(req->flags & REQ_CMD))
+               if (!blk_fs_request(req))
                        goto error_out;
 
                lo = req->rq_disk->private_data;
@@ -459,9 +475,9 @@ static void do_nbd_request(request_queue_t * q)
                req->errors = 0;
                spin_unlock_irq(q->queue_lock);
 
-               down(&lo->tx_lock);
+               mutex_lock(&lo->tx_lock);
                if (unlikely(!lo->sock)) {
-                       up(&lo->tx_lock);
+                       mutex_unlock(&lo->tx_lock);
                        printk(KERN_ERR "%s: Attempted send on closed socket\n",
                               lo->disk->disk_name);
                        req->errors++;
@@ -484,7 +500,7 @@ static void do_nbd_request(request_queue_t * q)
                }
 
                lo->active_req = NULL;
-               up(&lo->tx_lock);
+               mutex_unlock(&lo->tx_lock);
                wake_up_all(&lo->active_wq);
 
                spin_lock_irq(q->queue_lock);
@@ -496,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,
@@ -518,7 +533,7 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
        switch (cmd) {
        case NBD_DISCONNECT:
                printk(KERN_INFO "%s: NBD_DISCONNECT\n", lo->disk->disk_name);
-               sreq.flags = REQ_SPECIAL;
+               sreq.cmd_type = REQ_TYPE_SPECIAL;
                nbd_cmd(&sreq) = NBD_CMD_DISC;
                /*
                 * Set these to sane values in case server implementation
@@ -529,14 +544,16 @@ 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:
                error = 0;
-               down(&lo->tx_lock);
+               mutex_lock(&lo->tx_lock);
                lo->sock = NULL;
-               up(&lo->tx_lock);
+               mutex_unlock(&lo->tx_lock);
                file = lo->file;
                lo->file = NULL;
                nbd_clear_que(lo);
@@ -550,7 +567,7 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
                error = -EINVAL;
                file = fget(arg);
                if (file) {
-                       inode = file->f_dentry->d_inode;
+                       inode = file->f_path.dentry->d_inode;
                        if (S_ISSOCK(inode->i_mode)) {
                                lo->file = file;
                                lo->sock = SOCKET_I(inode);
@@ -573,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;
@@ -582,29 +602,19 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
        case NBD_DO_IT:
                if (!lo->file)
                        return -EINVAL;
-               nbd_do_it(lo);
-               /* 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 */
-               down(&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;
-               }
-               up(&lo->tx_lock);
+               error = nbd_do_it(lo);
+               if (error)
+                       return error;
+               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:
                /*
@@ -639,10 +649,7 @@ static int __init nbd_init(void)
        int err = -ENOMEM;
        int i;
 
-       if (sizeof(struct nbd_request) != 28) {
-               printk(KERN_CRIT "nbd: sizeof nbd_request needs to be 28 in order to work!\n" );
-               return -EIO;
-       }
+       BUILD_BUG_ON(sizeof(struct nbd_request) != 28);
 
        if (nbds_max > MAX_NBD) {
                printk(KERN_CRIT "nbd: cannot allocate more than %u nbds; %u requested.\n", MAX_NBD,
@@ -675,7 +682,6 @@ static int __init nbd_init(void)
        printk(KERN_INFO "nbd: registered device at major %d\n", NBD_MAJOR);
        dprintk(DBG_INIT, "nbd: debugflags=0x%x\n", debugflags);
 
-       devfs_mk_dir("nbd");
        for (i = 0; i < nbds_max; i++) {
                struct gendisk *disk = nbd_dev[i].disk;
                nbd_dev[i].file = NULL;
@@ -683,18 +689,17 @@ static int __init nbd_init(void)
                nbd_dev[i].flags = 0;
                spin_lock_init(&nbd_dev[i].queue_lock);
                INIT_LIST_HEAD(&nbd_dev[i].queue_head);
-               init_MUTEX(&nbd_dev[i].tx_lock);
+               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);
-               sprintf(disk->devfs_name, "nbd/%d", i);
-               set_capacity(disk, 0x7ffffc00ULL << 1); /* 2 TB */
+               set_capacity(disk, 0);
                add_disk(disk);
        }
 
@@ -719,7 +724,6 @@ static void __exit nbd_cleanup(void)
                        put_disk(disk);
                }
        }
-       devfs_remove("nbd");
        unregister_blkdev(NBD_MAJOR, "nbd");
        printk(KERN_INFO "nbd: unregistered device at major %d\n", NBD_MAJOR);
 }