2 * Network block device - make block devices work over TCP
4 * Note that you can not swap over this thing, yet. Seems to work but
5 * deadlocks sometimes - you can not swap over TCP in general.
7 * Copyright 1997-2000 Pavel Machek <pavel@ucw.cz>
8 * Parts copyright 2001 Steven Whitehouse <steve@chygwyn.com>
10 * (part of code stolen from loop.c)
12 * 97-3-25 compiled 0-th version, not yet tested it
13 * (it did not work, BTW) (later that day) HEY! it works!
14 * (bit later) hmm, not that much... 2:00am next day:
15 * yes, it works, but it gives something like 50kB/sec
16 * 97-4-01 complete rewrite to make it possible for many requests at
17 * once to be processed
18 * 97-4-11 Making protocol independent of endianity etc.
19 * 97-9-13 Cosmetic changes
20 * 98-5-13 Attempt to make 64-bit-clean on 64-bit machines
21 * 99-1-11 Attempt to make 64-bit-clean on 32-bit machines <ankry@mif.pg.gda.pl>
22 * 01-2-27 Fix to store proper blockcount for kernel (calculated using
23 * BLOCK_SIZE_BITS, not device blocksize) <aga@permonline.ru>
24 * 01-3-11 Make nbd work with new Linux block layer code. It now supports
25 * plugging like all the other block devices. Also added in MSG_MORE to
26 * reduce number of partial TCP segments sent. <steve@chygwyn.com>
27 * 01-12-6 Fix deadlock condition by making queue locks independent of
28 * the transmit lock. <steve@chygwyn.com>
29 * 02-10-11 Allow hung xmit to be aborted via SIGKILL & various fixes.
30 * <Paul.Clements@SteelEye.com> <James.Bottomley@SteelEye.com>
31 * 03-06-22 Make nbd work with new linux 2.5 block layer design. This fixes
32 * memory corruption from module removal and possible memory corruption
33 * from sending/receiving disk data. <ldl@aros.net>
34 * 03-06-23 Cosmetic changes. <ldl@aros.net>
35 * 03-06-23 Enhance diagnostics support. <ldl@aros.net>
36 * 03-06-24 Remove unneeded blksize_bits field from nbd_device struct.
38 * 03-06-24 Cleanup PARANOIA usage & code. <ldl@aros.net>
39 * 04-02-19 Remove PARANOIA, plus various cleanups (Paul Clements)
40 * possible FIXME: make set_sock / set_blksize / set_size / do_it one syscall
41 * why not: would need access_ok and friends, would share yet another
42 * structure with userland
45 #include <linux/major.h>
47 #include <linux/blkdev.h>
48 #include <linux/module.h>
49 #include <linux/init.h>
50 #include <linux/sched.h>
52 #include <linux/bio.h>
53 #include <linux/stat.h>
54 #include <linux/errno.h>
55 #include <linux/file.h>
56 #include <linux/ioctl.h>
57 #include <linux/compiler.h>
58 #include <linux/err.h>
59 #include <linux/kernel.h>
62 #include <linux/devfs_fs_kernel.h>
64 #include <asm/uaccess.h>
65 #include <asm/system.h>
66 #include <asm/types.h>
68 #include <linux/nbd.h>
70 #define LO_MAGIC 0x68797548
73 #define dprintk(flags, fmt...)
75 #define dprintk(flags, fmt...) do { \
76 if (debugflags & (flags)) printk(KERN_DEBUG fmt); \
78 #define DBG_IOCTL 0x0004
79 #define DBG_INIT 0x0010
80 #define DBG_EXIT 0x0020
81 #define DBG_BLKDEV 0x0100
84 static unsigned int debugflags
;
85 static unsigned int nbds_max
= 16;
88 static struct nbd_device nbd_dev
[MAX_NBD
];
91 * Use just one lock (or at most 1 per NIC). Two arguments for this:
92 * 1. Each NIC is essentially a synchronization point for all servers
93 * accessed through that NIC so there's no need to have more locks
95 * 2. More locks lead to more "Dirty cache line bouncing" which will slow
96 * down each lock to the point where they're actually slower than just
98 * Thanks go to Jens Axboe and Al Viro for their LKML emails explaining this!
100 static DEFINE_SPINLOCK(nbd_lock
);
103 static const char *ioctl_cmd_to_ascii(int cmd
)
106 case NBD_SET_SOCK
: return "set-sock";
107 case NBD_SET_BLKSIZE
: return "set-blksize";
108 case NBD_SET_SIZE
: return "set-size";
109 case NBD_DO_IT
: return "do-it";
110 case NBD_CLEAR_SOCK
: return "clear-sock";
111 case NBD_CLEAR_QUE
: return "clear-que";
112 case NBD_PRINT_DEBUG
: return "print-debug";
113 case NBD_SET_SIZE_BLOCKS
: return "set-size-blocks";
114 case NBD_DISCONNECT
: return "disconnect";
115 case BLKROSET
: return "set-read-only";
116 case BLKFLSBUF
: return "flush-buffer-cache";
121 static const char *nbdcmd_to_ascii(int cmd
)
124 case NBD_CMD_READ
: return "read";
125 case NBD_CMD_WRITE
: return "write";
126 case NBD_CMD_DISC
: return "disconnect";
132 static void nbd_end_request(struct request
*req
)
134 int uptodate
= (req
->errors
== 0) ? 1 : 0;
135 request_queue_t
*q
= req
->q
;
138 dprintk(DBG_BLKDEV
, "%s: request %p: %s\n", req
->rq_disk
->disk_name
,
139 req
, uptodate
? "done": "failed");
141 spin_lock_irqsave(q
->queue_lock
, flags
);
142 if (!end_that_request_first(req
, uptodate
, req
->nr_sectors
)) {
143 end_that_request_last(req
, uptodate
);
145 spin_unlock_irqrestore(q
->queue_lock
, flags
);
149 * Send or receive packet.
151 static int sock_xmit(struct socket
*sock
, int send
, void *buf
, int size
,
160 /* Allow interception of SIGKILL only
161 * Don't allow other signals to interrupt the transmission */
162 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
163 oldset
= current
->blocked
;
164 sigfillset(¤t
->blocked
);
165 sigdelsetmask(¤t
->blocked
, sigmask(SIGKILL
));
167 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
170 sock
->sk
->sk_allocation
= GFP_NOIO
;
175 msg
.msg_control
= NULL
;
176 msg
.msg_controllen
= 0;
178 msg
.msg_flags
= msg_flags
| MSG_NOSIGNAL
;
181 result
= kernel_sendmsg(sock
, &msg
, &iov
, 1, size
);
183 result
= kernel_recvmsg(sock
, &msg
, &iov
, 1, size
, 0);
185 if (signal_pending(current
)) {
187 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
188 printk(KERN_WARNING
"nbd (pid %d: %s) got signal %d\n",
189 current
->pid
, current
->comm
,
190 dequeue_signal(current
, ¤t
->blocked
, &info
));
191 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
198 result
= -EPIPE
; /* short read */
205 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
206 current
->blocked
= oldset
;
208 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
213 static inline int sock_send_bvec(struct socket
*sock
, struct bio_vec
*bvec
,
217 void *kaddr
= kmap(bvec
->bv_page
);
218 result
= sock_xmit(sock
, 1, kaddr
+ bvec
->bv_offset
, bvec
->bv_len
,
220 kunmap(bvec
->bv_page
);
224 static int nbd_send_req(struct nbd_device
*lo
, struct request
*req
)
226 int result
, i
, flags
;
227 struct nbd_request request
;
228 unsigned long size
= req
->nr_sectors
<< 9;
229 struct socket
*sock
= lo
->sock
;
231 request
.magic
= htonl(NBD_REQUEST_MAGIC
);
232 request
.type
= htonl(nbd_cmd(req
));
233 request
.from
= cpu_to_be64((u64
) req
->sector
<< 9);
234 request
.len
= htonl(size
);
235 memcpy(request
.handle
, &req
, sizeof(req
));
237 dprintk(DBG_TX
, "%s: request %p: sending control (%s@%llu,%luB)\n",
238 lo
->disk
->disk_name
, req
,
239 nbdcmd_to_ascii(nbd_cmd(req
)),
240 (unsigned long long)req
->sector
<< 9,
241 req
->nr_sectors
<< 9);
242 result
= sock_xmit(sock
, 1, &request
, sizeof(request
),
243 (nbd_cmd(req
) == NBD_CMD_WRITE
)? MSG_MORE
: 0);
245 printk(KERN_ERR
"%s: Send control failed (result %d)\n",
246 lo
->disk
->disk_name
, result
);
250 if (nbd_cmd(req
) == NBD_CMD_WRITE
) {
253 * we are really probing at internals to determine
254 * whether to set MSG_MORE or not...
256 rq_for_each_bio(bio
, req
) {
257 struct bio_vec
*bvec
;
258 bio_for_each_segment(bvec
, bio
, i
) {
260 if ((i
< (bio
->bi_vcnt
- 1)) || bio
->bi_next
)
262 dprintk(DBG_TX
, "%s: request %p: sending %d bytes data\n",
263 lo
->disk
->disk_name
, req
,
265 result
= sock_send_bvec(sock
, bvec
, flags
);
267 printk(KERN_ERR
"%s: Send data failed (result %d)\n",
281 static struct request
*nbd_find_request(struct nbd_device
*lo
, char *handle
)
284 struct list_head
*tmp
;
285 struct request
*xreq
;
288 memcpy(&xreq
, handle
, sizeof(xreq
));
290 err
= wait_event_interruptible(lo
->active_wq
, lo
->active_req
!= xreq
);
294 spin_lock(&lo
->queue_lock
);
295 list_for_each(tmp
, &lo
->queue_head
) {
296 req
= list_entry(tmp
, struct request
, queuelist
);
299 list_del_init(&req
->queuelist
);
300 spin_unlock(&lo
->queue_lock
);
303 spin_unlock(&lo
->queue_lock
);
311 static inline int sock_recv_bvec(struct socket
*sock
, struct bio_vec
*bvec
)
314 void *kaddr
= kmap(bvec
->bv_page
);
315 result
= sock_xmit(sock
, 0, kaddr
+ bvec
->bv_offset
, bvec
->bv_len
,
317 kunmap(bvec
->bv_page
);
321 /* NULL returned = something went wrong, inform userspace */
322 static struct request
*nbd_read_stat(struct nbd_device
*lo
)
325 struct nbd_reply reply
;
327 struct socket
*sock
= lo
->sock
;
330 result
= sock_xmit(sock
, 0, &reply
, sizeof(reply
), MSG_WAITALL
);
332 printk(KERN_ERR
"%s: Receive control failed (result %d)\n",
333 lo
->disk
->disk_name
, result
);
336 req
= nbd_find_request(lo
, reply
.handle
);
337 if (unlikely(IS_ERR(req
))) {
338 result
= PTR_ERR(req
);
339 if (result
!= -ENOENT
)
342 printk(KERN_ERR
"%s: Unexpected reply (%p)\n",
343 lo
->disk
->disk_name
, reply
.handle
);
348 if (ntohl(reply
.magic
) != NBD_REPLY_MAGIC
) {
349 printk(KERN_ERR
"%s: Wrong magic (0x%lx)\n",
351 (unsigned long)ntohl(reply
.magic
));
355 if (ntohl(reply
.error
)) {
356 printk(KERN_ERR
"%s: Other side returned error (%d)\n",
357 lo
->disk
->disk_name
, ntohl(reply
.error
));
362 dprintk(DBG_RX
, "%s: request %p: got reply\n",
363 lo
->disk
->disk_name
, req
);
364 if (nbd_cmd(req
) == NBD_CMD_READ
) {
367 rq_for_each_bio(bio
, req
) {
368 struct bio_vec
*bvec
;
369 bio_for_each_segment(bvec
, bio
, i
) {
370 result
= sock_recv_bvec(sock
, bvec
);
372 printk(KERN_ERR
"%s: Receive data failed (result %d)\n",
377 dprintk(DBG_RX
, "%s: request %p: got %d bytes data\n",
378 lo
->disk
->disk_name
, req
, bvec
->bv_len
);
384 lo
->harderror
= result
;
388 static void nbd_do_it(struct nbd_device
*lo
)
392 BUG_ON(lo
->magic
!= LO_MAGIC
);
394 while ((req
= nbd_read_stat(lo
)) != NULL
)
395 nbd_end_request(req
);
399 static void nbd_clear_que(struct nbd_device
*lo
)
403 BUG_ON(lo
->magic
!= LO_MAGIC
);
406 * Because we have set lo->sock to NULL under the tx_lock, all
407 * modifications to the list must have completed by now. For
408 * the same reason, the active_req must be NULL.
410 * As a consequence, we don't need to take the spin lock while
411 * purging the list here.
414 BUG_ON(lo
->active_req
);
416 while (!list_empty(&lo
->queue_head
)) {
417 req
= list_entry(lo
->queue_head
.next
, struct request
,
419 list_del_init(&req
->queuelist
);
421 nbd_end_request(req
);
426 * We always wait for result of write, for now. It would be nice to make it optional
428 * if ((req->cmd == WRITE) && (lo->flags & NBD_WRITE_NOCHK))
429 * { printk( "Warning: Ignoring result!\n"); nbd_end_request( req ); }
432 static void do_nbd_request(request_queue_t
* q
)
436 while ((req
= elv_next_request(q
)) != NULL
) {
437 struct nbd_device
*lo
;
439 blkdev_dequeue_request(req
);
440 dprintk(DBG_BLKDEV
, "%s: request %p: dequeued (flags=%lx)\n",
441 req
->rq_disk
->disk_name
, req
, req
->flags
);
443 if (!(req
->flags
& REQ_CMD
))
446 lo
= req
->rq_disk
->private_data
;
448 BUG_ON(lo
->magic
!= LO_MAGIC
);
450 nbd_cmd(req
) = NBD_CMD_READ
;
451 if (rq_data_dir(req
) == WRITE
) {
452 nbd_cmd(req
) = NBD_CMD_WRITE
;
453 if (lo
->flags
& NBD_READ_ONLY
) {
454 printk(KERN_ERR
"%s: Write on read-only\n",
455 lo
->disk
->disk_name
);
461 spin_unlock_irq(q
->queue_lock
);
464 if (unlikely(!lo
->sock
)) {
466 printk(KERN_ERR
"%s: Attempted send on closed socket\n",
467 lo
->disk
->disk_name
);
469 nbd_end_request(req
);
470 spin_lock_irq(q
->queue_lock
);
474 lo
->active_req
= req
;
476 if (nbd_send_req(lo
, req
) != 0) {
477 printk(KERN_ERR
"%s: Request send failed\n",
478 lo
->disk
->disk_name
);
480 nbd_end_request(req
);
482 spin_lock(&lo
->queue_lock
);
483 list_add(&req
->queuelist
, &lo
->queue_head
);
484 spin_unlock(&lo
->queue_lock
);
487 lo
->active_req
= NULL
;
489 wake_up_all(&lo
->active_wq
);
491 spin_lock_irq(q
->queue_lock
);
496 spin_unlock(q
->queue_lock
);
497 nbd_end_request(req
);
498 spin_lock(q
->queue_lock
);
503 static int nbd_ioctl(struct inode
*inode
, struct file
*file
,
504 unsigned int cmd
, unsigned long arg
)
506 struct nbd_device
*lo
= inode
->i_bdev
->bd_disk
->private_data
;
508 struct request sreq
;
510 if (!capable(CAP_SYS_ADMIN
))
513 BUG_ON(lo
->magic
!= LO_MAGIC
);
515 /* Anyone capable of this syscall can do *real bad* things */
516 dprintk(DBG_IOCTL
, "%s: nbd_ioctl cmd=%s(0x%x) arg=%lu\n",
517 lo
->disk
->disk_name
, ioctl_cmd_to_ascii(cmd
), cmd
, arg
);
521 printk(KERN_INFO
"%s: NBD_DISCONNECT\n", lo
->disk
->disk_name
);
522 sreq
.flags
= REQ_SPECIAL
;
523 nbd_cmd(&sreq
) = NBD_CMD_DISC
;
525 * Set these to sane values in case server implementation
526 * fails to check the request type first and also to keep
527 * debugging output cleaner.
533 nbd_send_req(lo
, &sreq
);
544 BUG_ON(!list_empty(&lo
->queue_head
));
554 inode
= file
->f_dentry
->d_inode
;
555 if (S_ISSOCK(inode
->i_mode
)) {
557 lo
->sock
= SOCKET_I(inode
);
564 case NBD_SET_BLKSIZE
:
566 lo
->bytesize
&= ~(lo
->blksize
-1);
567 inode
->i_bdev
->bd_inode
->i_size
= lo
->bytesize
;
568 set_blocksize(inode
->i_bdev
, lo
->blksize
);
569 set_capacity(lo
->disk
, lo
->bytesize
>> 9);
572 lo
->bytesize
= arg
& ~(lo
->blksize
-1);
573 inode
->i_bdev
->bd_inode
->i_size
= lo
->bytesize
;
574 set_blocksize(inode
->i_bdev
, lo
->blksize
);
575 set_capacity(lo
->disk
, lo
->bytesize
>> 9);
577 case NBD_SET_SIZE_BLOCKS
:
578 lo
->bytesize
= ((u64
) arg
) * lo
->blksize
;
579 inode
->i_bdev
->bd_inode
->i_size
= lo
->bytesize
;
580 set_blocksize(inode
->i_bdev
, lo
->blksize
);
581 set_capacity(lo
->disk
, lo
->bytesize
>> 9);
587 /* on return tidy up in case we have a signal */
588 /* Forcibly shutdown the socket causing all listeners
591 * FIXME: This code is duplicated from sys_shutdown, but
592 * there should be a more generic interface rather than
593 * calling socket ops directly here */
596 printk(KERN_WARNING
"%s: shutting down socket\n",
597 lo
->disk
->disk_name
);
598 lo
->sock
->ops
->shutdown(lo
->sock
,
599 SEND_SHUTDOWN
|RCV_SHUTDOWN
);
606 printk(KERN_WARNING
"%s: queue cleared\n", lo
->disk
->disk_name
);
609 return lo
->harderror
;
612 * This is for compatibility only. The queue is always cleared
613 * by NBD_DO_IT or NBD_CLEAR_SOCK.
615 BUG_ON(!lo
->sock
&& !list_empty(&lo
->queue_head
));
617 case NBD_PRINT_DEBUG
:
618 printk(KERN_INFO
"%s: next = %p, prev = %p, head = %p\n",
619 inode
->i_bdev
->bd_disk
->disk_name
,
620 lo
->queue_head
.next
, lo
->queue_head
.prev
,
627 static struct block_device_operations nbd_fops
=
629 .owner
= THIS_MODULE
,
634 * And here should be modules and kernel interface
635 * (Just smiley confuses emacs :-)
638 static int __init
nbd_init(void)
643 if (sizeof(struct nbd_request
) != 28) {
644 printk(KERN_CRIT
"nbd: sizeof nbd_request needs to be 28 in order to work!\n" );
648 if (nbds_max
> MAX_NBD
) {
649 printk(KERN_CRIT
"nbd: cannot allocate more than %u nbds; %u requested.\n", MAX_NBD
,
654 for (i
= 0; i
< nbds_max
; i
++) {
655 struct gendisk
*disk
= alloc_disk(1);
658 nbd_dev
[i
].disk
= disk
;
660 * The new linux 2.5 block layer implementation requires
661 * every gendisk to have its very own request_queue struct.
662 * These structs are big so we dynamically allocate them.
664 disk
->queue
= blk_init_queue(do_nbd_request
, &nbd_lock
);
671 if (register_blkdev(NBD_MAJOR
, "nbd")) {
676 printk(KERN_INFO
"nbd: registered device at major %d\n", NBD_MAJOR
);
677 dprintk(DBG_INIT
, "nbd: debugflags=0x%x\n", debugflags
);
680 for (i
= 0; i
< nbds_max
; i
++) {
681 struct gendisk
*disk
= nbd_dev
[i
].disk
;
682 nbd_dev
[i
].file
= NULL
;
683 nbd_dev
[i
].magic
= LO_MAGIC
;
684 nbd_dev
[i
].flags
= 0;
685 spin_lock_init(&nbd_dev
[i
].queue_lock
);
686 INIT_LIST_HEAD(&nbd_dev
[i
].queue_head
);
687 init_MUTEX(&nbd_dev
[i
].tx_lock
);
688 init_waitqueue_head(&nbd_dev
[i
].active_wq
);
689 nbd_dev
[i
].blksize
= 1024;
690 nbd_dev
[i
].bytesize
= 0x7ffffc00ULL
<< 10; /* 2TB */
691 disk
->major
= NBD_MAJOR
;
692 disk
->first_minor
= i
;
693 disk
->fops
= &nbd_fops
;
694 disk
->private_data
= &nbd_dev
[i
];
695 disk
->flags
|= GENHD_FL_SUPPRESS_PARTITION_INFO
;
696 sprintf(disk
->disk_name
, "nbd%d", i
);
697 sprintf(disk
->devfs_name
, "nbd/%d", i
);
698 set_capacity(disk
, 0x7ffffc00ULL
<< 1); /* 2 TB */
705 blk_cleanup_queue(nbd_dev
[i
].disk
->queue
);
706 put_disk(nbd_dev
[i
].disk
);
711 static void __exit
nbd_cleanup(void)
714 for (i
= 0; i
< nbds_max
; i
++) {
715 struct gendisk
*disk
= nbd_dev
[i
].disk
;
716 nbd_dev
[i
].magic
= 0;
719 blk_cleanup_queue(disk
->queue
);
724 unregister_blkdev(NBD_MAJOR
, "nbd");
725 printk(KERN_INFO
"nbd: unregistered device at major %d\n", NBD_MAJOR
);
728 module_init(nbd_init
);
729 module_exit(nbd_cleanup
);
731 MODULE_DESCRIPTION("Network Block Device");
732 MODULE_LICENSE("GPL");
734 module_param(nbds_max
, int, 0444);
735 MODULE_PARM_DESC(nbds_max
, "How many network block devices to initialize.");
737 module_param(debugflags
, int, 0644);
738 MODULE_PARM_DESC(debugflags
, "flags for controlling debug output");