xref: /openbmc/linux/drivers/block/nbd.c (revision 643d1f7f)
1 /*
2  * Network block device - make block devices work over TCP
3  *
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.
6  *
7  * Copyright 1997-2000 Pavel Machek <pavel@ucw.cz>
8  * Parts copyright 2001 Steven Whitehouse <steve@chygwyn.com>
9  *
10  * This file is released under GPLv2 or later.
11  *
12  * (part of code stolen from loop.c)
13  */
14 
15 #include <linux/major.h>
16 
17 #include <linux/blkdev.h>
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/sched.h>
21 #include <linux/fs.h>
22 #include <linux/bio.h>
23 #include <linux/stat.h>
24 #include <linux/errno.h>
25 #include <linux/file.h>
26 #include <linux/ioctl.h>
27 #include <linux/compiler.h>
28 #include <linux/err.h>
29 #include <linux/kernel.h>
30 #include <net/sock.h>
31 #include <linux/net.h>
32 
33 #include <asm/uaccess.h>
34 #include <asm/system.h>
35 #include <asm/types.h>
36 
37 #include <linux/nbd.h>
38 
39 #define LO_MAGIC 0x68797548
40 
41 #ifdef NDEBUG
42 #define dprintk(flags, fmt...)
43 #else /* NDEBUG */
44 #define dprintk(flags, fmt...) do { \
45 	if (debugflags & (flags)) printk(KERN_DEBUG fmt); \
46 } while (0)
47 #define DBG_IOCTL       0x0004
48 #define DBG_INIT        0x0010
49 #define DBG_EXIT        0x0020
50 #define DBG_BLKDEV      0x0100
51 #define DBG_RX          0x0200
52 #define DBG_TX          0x0400
53 static unsigned int debugflags;
54 #endif /* NDEBUG */
55 
56 static unsigned int nbds_max = 16;
57 static struct nbd_device nbd_dev[MAX_NBD];
58 
59 /*
60  * Use just one lock (or at most 1 per NIC). Two arguments for this:
61  * 1. Each NIC is essentially a synchronization point for all servers
62  *    accessed through that NIC so there's no need to have more locks
63  *    than NICs anyway.
64  * 2. More locks lead to more "Dirty cache line bouncing" which will slow
65  *    down each lock to the point where they're actually slower than just
66  *    a single lock.
67  * Thanks go to Jens Axboe and Al Viro for their LKML emails explaining this!
68  */
69 static DEFINE_SPINLOCK(nbd_lock);
70 
71 #ifndef NDEBUG
72 static const char *ioctl_cmd_to_ascii(int cmd)
73 {
74 	switch (cmd) {
75 	case NBD_SET_SOCK: return "set-sock";
76 	case NBD_SET_BLKSIZE: return "set-blksize";
77 	case NBD_SET_SIZE: return "set-size";
78 	case NBD_DO_IT: return "do-it";
79 	case NBD_CLEAR_SOCK: return "clear-sock";
80 	case NBD_CLEAR_QUE: return "clear-que";
81 	case NBD_PRINT_DEBUG: return "print-debug";
82 	case NBD_SET_SIZE_BLOCKS: return "set-size-blocks";
83 	case NBD_DISCONNECT: return "disconnect";
84 	case BLKROSET: return "set-read-only";
85 	case BLKFLSBUF: return "flush-buffer-cache";
86 	}
87 	return "unknown";
88 }
89 
90 static const char *nbdcmd_to_ascii(int cmd)
91 {
92 	switch (cmd) {
93 	case  NBD_CMD_READ: return "read";
94 	case NBD_CMD_WRITE: return "write";
95 	case  NBD_CMD_DISC: return "disconnect";
96 	}
97 	return "invalid";
98 }
99 #endif /* NDEBUG */
100 
101 static void nbd_end_request(struct request *req)
102 {
103 	int error = req->errors ? -EIO : 0;
104 	struct request_queue *q = req->q;
105 	unsigned long flags;
106 
107 	dprintk(DBG_BLKDEV, "%s: request %p: %s\n", req->rq_disk->disk_name,
108 			req, error ? "failed" : "done");
109 
110 	spin_lock_irqsave(q->queue_lock, flags);
111 	__blk_end_request(req, error, req->nr_sectors << 9);
112 	spin_unlock_irqrestore(q->queue_lock, flags);
113 }
114 
115 static void sock_shutdown(struct nbd_device *lo, int lock)
116 {
117 	/* Forcibly shutdown the socket causing all listeners
118 	 * to error
119 	 *
120 	 * FIXME: This code is duplicated from sys_shutdown, but
121 	 * there should be a more generic interface rather than
122 	 * calling socket ops directly here */
123 	if (lock)
124 		mutex_lock(&lo->tx_lock);
125 	if (lo->sock) {
126 		printk(KERN_WARNING "%s: shutting down socket\n",
127 			lo->disk->disk_name);
128 		kernel_sock_shutdown(lo->sock, SHUT_RDWR);
129 		lo->sock = NULL;
130 	}
131 	if (lock)
132 		mutex_unlock(&lo->tx_lock);
133 }
134 
135 static void nbd_xmit_timeout(unsigned long arg)
136 {
137 	struct task_struct *task = (struct task_struct *)arg;
138 
139 	printk(KERN_WARNING "nbd: killing hung xmit (%s, pid: %d)\n",
140 		task->comm, task->pid);
141 	force_sig(SIGKILL, task);
142 }
143 
144 /*
145  *  Send or receive packet.
146  */
147 static int sock_xmit(struct nbd_device *lo, int send, void *buf, int size,
148 		int msg_flags)
149 {
150 	struct socket *sock = lo->sock;
151 	int result;
152 	struct msghdr msg;
153 	struct kvec iov;
154 	sigset_t blocked, oldset;
155 
156 	/* Allow interception of SIGKILL only
157 	 * Don't allow other signals to interrupt the transmission */
158 	siginitsetinv(&blocked, sigmask(SIGKILL));
159 	sigprocmask(SIG_SETMASK, &blocked, &oldset);
160 
161 	do {
162 		sock->sk->sk_allocation = GFP_NOIO;
163 		iov.iov_base = buf;
164 		iov.iov_len = size;
165 		msg.msg_name = NULL;
166 		msg.msg_namelen = 0;
167 		msg.msg_control = NULL;
168 		msg.msg_controllen = 0;
169 		msg.msg_flags = msg_flags | MSG_NOSIGNAL;
170 
171 		if (send) {
172 			struct timer_list ti;
173 
174 			if (lo->xmit_timeout) {
175 				init_timer(&ti);
176 				ti.function = nbd_xmit_timeout;
177 				ti.data = (unsigned long)current;
178 				ti.expires = jiffies + lo->xmit_timeout;
179 				add_timer(&ti);
180 			}
181 			result = kernel_sendmsg(sock, &msg, &iov, 1, size);
182 			if (lo->xmit_timeout)
183 				del_timer_sync(&ti);
184 		} else
185 			result = kernel_recvmsg(sock, &msg, &iov, 1, size, 0);
186 
187 		if (signal_pending(current)) {
188 			siginfo_t info;
189 			printk(KERN_WARNING "nbd (pid %d: %s) got signal %d\n",
190 				task_pid_nr(current), current->comm,
191 				dequeue_signal_lock(current, &current->blocked, &info));
192 			result = -EINTR;
193 			sock_shutdown(lo, !send);
194 			break;
195 		}
196 
197 		if (result <= 0) {
198 			if (result == 0)
199 				result = -EPIPE; /* short read */
200 			break;
201 		}
202 		size -= result;
203 		buf += result;
204 	} while (size > 0);
205 
206 	sigprocmask(SIG_SETMASK, &oldset, NULL);
207 
208 	return result;
209 }
210 
211 static inline int sock_send_bvec(struct nbd_device *lo, struct bio_vec *bvec,
212 		int flags)
213 {
214 	int result;
215 	void *kaddr = kmap(bvec->bv_page);
216 	result = sock_xmit(lo, 1, kaddr + bvec->bv_offset, bvec->bv_len, flags);
217 	kunmap(bvec->bv_page);
218 	return result;
219 }
220 
221 /* always call with the tx_lock held */
222 static int nbd_send_req(struct nbd_device *lo, struct request *req)
223 {
224 	int result, flags;
225 	struct nbd_request request;
226 	unsigned long size = req->nr_sectors << 9;
227 
228 	request.magic = htonl(NBD_REQUEST_MAGIC);
229 	request.type = htonl(nbd_cmd(req));
230 	request.from = cpu_to_be64((u64) req->sector << 9);
231 	request.len = htonl(size);
232 	memcpy(request.handle, &req, sizeof(req));
233 
234 	dprintk(DBG_TX, "%s: request %p: sending control (%s@%llu,%luB)\n",
235 			lo->disk->disk_name, req,
236 			nbdcmd_to_ascii(nbd_cmd(req)),
237 			(unsigned long long)req->sector << 9,
238 			req->nr_sectors << 9);
239 	result = sock_xmit(lo, 1, &request, sizeof(request),
240 			(nbd_cmd(req) == NBD_CMD_WRITE) ? MSG_MORE : 0);
241 	if (result <= 0) {
242 		printk(KERN_ERR "%s: Send control failed (result %d)\n",
243 				lo->disk->disk_name, result);
244 		goto error_out;
245 	}
246 
247 	if (nbd_cmd(req) == NBD_CMD_WRITE) {
248 		struct req_iterator iter;
249 		struct bio_vec *bvec;
250 		/*
251 		 * we are really probing at internals to determine
252 		 * whether to set MSG_MORE or not...
253 		 */
254 		rq_for_each_segment(bvec, req, iter) {
255 			flags = 0;
256 			if (!rq_iter_last(req, iter))
257 				flags = MSG_MORE;
258 			dprintk(DBG_TX, "%s: request %p: sending %d bytes data\n",
259 					lo->disk->disk_name, req, bvec->bv_len);
260 			result = sock_send_bvec(lo, bvec, flags);
261 			if (result <= 0) {
262 				printk(KERN_ERR "%s: Send data failed (result %d)\n",
263 						lo->disk->disk_name, result);
264 				goto error_out;
265 			}
266 		}
267 	}
268 	return 0;
269 
270 error_out:
271 	return 1;
272 }
273 
274 static struct request *nbd_find_request(struct nbd_device *lo,
275 					struct request *xreq)
276 {
277 	struct request *req, *tmp;
278 	int err;
279 
280 	err = wait_event_interruptible(lo->active_wq, lo->active_req != xreq);
281 	if (unlikely(err))
282 		goto out;
283 
284 	spin_lock(&lo->queue_lock);
285 	list_for_each_entry_safe(req, tmp, &lo->queue_head, queuelist) {
286 		if (req != xreq)
287 			continue;
288 		list_del_init(&req->queuelist);
289 		spin_unlock(&lo->queue_lock);
290 		return req;
291 	}
292 	spin_unlock(&lo->queue_lock);
293 
294 	err = -ENOENT;
295 
296 out:
297 	return ERR_PTR(err);
298 }
299 
300 static inline int sock_recv_bvec(struct nbd_device *lo, struct bio_vec *bvec)
301 {
302 	int result;
303 	void *kaddr = kmap(bvec->bv_page);
304 	result = sock_xmit(lo, 0, kaddr + bvec->bv_offset, bvec->bv_len,
305 			MSG_WAITALL);
306 	kunmap(bvec->bv_page);
307 	return result;
308 }
309 
310 /* NULL returned = something went wrong, inform userspace */
311 static struct request *nbd_read_stat(struct nbd_device *lo)
312 {
313 	int result;
314 	struct nbd_reply reply;
315 	struct request *req;
316 
317 	reply.magic = 0;
318 	result = sock_xmit(lo, 0, &reply, sizeof(reply), MSG_WAITALL);
319 	if (result <= 0) {
320 		printk(KERN_ERR "%s: Receive control failed (result %d)\n",
321 				lo->disk->disk_name, result);
322 		goto harderror;
323 	}
324 
325 	if (ntohl(reply.magic) != NBD_REPLY_MAGIC) {
326 		printk(KERN_ERR "%s: Wrong magic (0x%lx)\n",
327 				lo->disk->disk_name,
328 				(unsigned long)ntohl(reply.magic));
329 		result = -EPROTO;
330 		goto harderror;
331 	}
332 
333 	req = nbd_find_request(lo, *(struct request **)reply.handle);
334 	if (unlikely(IS_ERR(req))) {
335 		result = PTR_ERR(req);
336 		if (result != -ENOENT)
337 			goto harderror;
338 
339 		printk(KERN_ERR "%s: Unexpected reply (%p)\n",
340 				lo->disk->disk_name, reply.handle);
341 		result = -EBADR;
342 		goto harderror;
343 	}
344 
345 	if (ntohl(reply.error)) {
346 		printk(KERN_ERR "%s: Other side returned error (%d)\n",
347 				lo->disk->disk_name, ntohl(reply.error));
348 		req->errors++;
349 		return req;
350 	}
351 
352 	dprintk(DBG_RX, "%s: request %p: got reply\n",
353 			lo->disk->disk_name, req);
354 	if (nbd_cmd(req) == NBD_CMD_READ) {
355 		struct req_iterator iter;
356 		struct bio_vec *bvec;
357 
358 		rq_for_each_segment(bvec, req, iter) {
359 			result = sock_recv_bvec(lo, bvec);
360 			if (result <= 0) {
361 				printk(KERN_ERR "%s: Receive data failed (result %d)\n",
362 						lo->disk->disk_name, result);
363 				req->errors++;
364 				return req;
365 			}
366 			dprintk(DBG_RX, "%s: request %p: got %d bytes data\n",
367 				lo->disk->disk_name, req, bvec->bv_len);
368 		}
369 	}
370 	return req;
371 harderror:
372 	lo->harderror = result;
373 	return NULL;
374 }
375 
376 static ssize_t pid_show(struct device *dev,
377 			struct device_attribute *attr, char *buf)
378 {
379 	struct gendisk *disk = dev_to_disk(dev);
380 
381 	return sprintf(buf, "%ld\n",
382 		(long) ((struct nbd_device *)disk->private_data)->pid);
383 }
384 
385 static struct device_attribute pid_attr = {
386 	.attr = { .name = "pid", .mode = S_IRUGO, .owner = THIS_MODULE },
387 	.show = pid_show,
388 };
389 
390 static int nbd_do_it(struct nbd_device *lo)
391 {
392 	struct request *req;
393 	int ret;
394 
395 	BUG_ON(lo->magic != LO_MAGIC);
396 
397 	lo->pid = current->pid;
398 	ret = sysfs_create_file(&lo->disk->dev.kobj, &pid_attr.attr);
399 	if (ret) {
400 		printk(KERN_ERR "nbd: sysfs_create_file failed!");
401 		return ret;
402 	}
403 
404 	while ((req = nbd_read_stat(lo)) != NULL)
405 		nbd_end_request(req);
406 
407 	sysfs_remove_file(&lo->disk->dev.kobj, &pid_attr.attr);
408 	return 0;
409 }
410 
411 static void nbd_clear_que(struct nbd_device *lo)
412 {
413 	struct request *req;
414 
415 	BUG_ON(lo->magic != LO_MAGIC);
416 
417 	/*
418 	 * Because we have set lo->sock to NULL under the tx_lock, all
419 	 * modifications to the list must have completed by now.  For
420 	 * the same reason, the active_req must be NULL.
421 	 *
422 	 * As a consequence, we don't need to take the spin lock while
423 	 * purging the list here.
424 	 */
425 	BUG_ON(lo->sock);
426 	BUG_ON(lo->active_req);
427 
428 	while (!list_empty(&lo->queue_head)) {
429 		req = list_entry(lo->queue_head.next, struct request,
430 				 queuelist);
431 		list_del_init(&req->queuelist);
432 		req->errors++;
433 		nbd_end_request(req);
434 	}
435 }
436 
437 
438 /*
439  * We always wait for result of write, for now. It would be nice to make it optional
440  * in future
441  * if ((rq_data_dir(req) == WRITE) && (lo->flags & NBD_WRITE_NOCHK))
442  *   { printk( "Warning: Ignoring result!\n"); nbd_end_request( req ); }
443  */
444 
445 static void do_nbd_request(struct request_queue * q)
446 {
447 	struct request *req;
448 
449 	while ((req = elv_next_request(q)) != NULL) {
450 		struct nbd_device *lo;
451 
452 		blkdev_dequeue_request(req);
453 		dprintk(DBG_BLKDEV, "%s: request %p: dequeued (flags=%x)\n",
454 				req->rq_disk->disk_name, req, req->cmd_type);
455 
456 		if (!blk_fs_request(req))
457 			goto error_out;
458 
459 		lo = req->rq_disk->private_data;
460 
461 		BUG_ON(lo->magic != LO_MAGIC);
462 
463 		nbd_cmd(req) = NBD_CMD_READ;
464 		if (rq_data_dir(req) == WRITE) {
465 			nbd_cmd(req) = NBD_CMD_WRITE;
466 			if (lo->flags & NBD_READ_ONLY) {
467 				printk(KERN_ERR "%s: Write on read-only\n",
468 						lo->disk->disk_name);
469 				goto error_out;
470 			}
471 		}
472 
473 		req->errors = 0;
474 		spin_unlock_irq(q->queue_lock);
475 
476 		mutex_lock(&lo->tx_lock);
477 		if (unlikely(!lo->sock)) {
478 			mutex_unlock(&lo->tx_lock);
479 			printk(KERN_ERR "%s: Attempted send on closed socket\n",
480 			       lo->disk->disk_name);
481 			req->errors++;
482 			nbd_end_request(req);
483 			spin_lock_irq(q->queue_lock);
484 			continue;
485 		}
486 
487 		lo->active_req = req;
488 
489 		if (nbd_send_req(lo, req) != 0) {
490 			printk(KERN_ERR "%s: Request send failed\n",
491 					lo->disk->disk_name);
492 			req->errors++;
493 			nbd_end_request(req);
494 		} else {
495 			spin_lock(&lo->queue_lock);
496 			list_add(&req->queuelist, &lo->queue_head);
497 			spin_unlock(&lo->queue_lock);
498 		}
499 
500 		lo->active_req = NULL;
501 		mutex_unlock(&lo->tx_lock);
502 		wake_up_all(&lo->active_wq);
503 
504 		spin_lock_irq(q->queue_lock);
505 		continue;
506 
507 error_out:
508 		req->errors++;
509 		spin_unlock(q->queue_lock);
510 		nbd_end_request(req);
511 		spin_lock(q->queue_lock);
512 	}
513 }
514 
515 static int nbd_ioctl(struct inode *inode, struct file *file,
516 		     unsigned int cmd, unsigned long arg)
517 {
518 	struct nbd_device *lo = inode->i_bdev->bd_disk->private_data;
519 	int error;
520 	struct request sreq ;
521 
522 	if (!capable(CAP_SYS_ADMIN))
523 		return -EPERM;
524 
525 	BUG_ON(lo->magic != LO_MAGIC);
526 
527 	/* Anyone capable of this syscall can do *real bad* things */
528 	dprintk(DBG_IOCTL, "%s: nbd_ioctl cmd=%s(0x%x) arg=%lu\n",
529 			lo->disk->disk_name, ioctl_cmd_to_ascii(cmd), cmd, arg);
530 
531 	switch (cmd) {
532 	case NBD_DISCONNECT:
533 	        printk(KERN_INFO "%s: NBD_DISCONNECT\n", lo->disk->disk_name);
534 		sreq.cmd_type = REQ_TYPE_SPECIAL;
535 		nbd_cmd(&sreq) = NBD_CMD_DISC;
536 		/*
537 		 * Set these to sane values in case server implementation
538 		 * fails to check the request type first and also to keep
539 		 * debugging output cleaner.
540 		 */
541 		sreq.sector = 0;
542 		sreq.nr_sectors = 0;
543                 if (!lo->sock)
544 			return -EINVAL;
545 		mutex_lock(&lo->tx_lock);
546                 nbd_send_req(lo, &sreq);
547 		mutex_unlock(&lo->tx_lock);
548                 return 0;
549 
550 	case NBD_CLEAR_SOCK:
551 		error = 0;
552 		mutex_lock(&lo->tx_lock);
553 		lo->sock = NULL;
554 		mutex_unlock(&lo->tx_lock);
555 		file = lo->file;
556 		lo->file = NULL;
557 		nbd_clear_que(lo);
558 		BUG_ON(!list_empty(&lo->queue_head));
559 		if (file)
560 			fput(file);
561 		return error;
562 	case NBD_SET_SOCK:
563 		if (lo->file)
564 			return -EBUSY;
565 		error = -EINVAL;
566 		file = fget(arg);
567 		if (file) {
568 			inode = file->f_path.dentry->d_inode;
569 			if (S_ISSOCK(inode->i_mode)) {
570 				lo->file = file;
571 				lo->sock = SOCKET_I(inode);
572 				error = 0;
573 			} else {
574 				fput(file);
575 			}
576 		}
577 		return error;
578 	case NBD_SET_BLKSIZE:
579 		lo->blksize = arg;
580 		lo->bytesize &= ~(lo->blksize-1);
581 		inode->i_bdev->bd_inode->i_size = lo->bytesize;
582 		set_blocksize(inode->i_bdev, lo->blksize);
583 		set_capacity(lo->disk, lo->bytesize >> 9);
584 		return 0;
585 	case NBD_SET_SIZE:
586 		lo->bytesize = arg & ~(lo->blksize-1);
587 		inode->i_bdev->bd_inode->i_size = lo->bytesize;
588 		set_blocksize(inode->i_bdev, lo->blksize);
589 		set_capacity(lo->disk, lo->bytesize >> 9);
590 		return 0;
591 	case NBD_SET_TIMEOUT:
592 		lo->xmit_timeout = arg * HZ;
593 		return 0;
594 	case NBD_SET_SIZE_BLOCKS:
595 		lo->bytesize = ((u64) arg) * lo->blksize;
596 		inode->i_bdev->bd_inode->i_size = lo->bytesize;
597 		set_blocksize(inode->i_bdev, lo->blksize);
598 		set_capacity(lo->disk, lo->bytesize >> 9);
599 		return 0;
600 	case NBD_DO_IT:
601 		if (!lo->file)
602 			return -EINVAL;
603 		error = nbd_do_it(lo);
604 		if (error)
605 			return error;
606 		sock_shutdown(lo, 1);
607 		file = lo->file;
608 		lo->file = NULL;
609 		nbd_clear_que(lo);
610 		printk(KERN_WARNING "%s: queue cleared\n", lo->disk->disk_name);
611 		if (file)
612 			fput(file);
613 		lo->bytesize = 0;
614 		inode->i_bdev->bd_inode->i_size = 0;
615 		set_capacity(lo->disk, 0);
616 		return lo->harderror;
617 	case NBD_CLEAR_QUE:
618 		/*
619 		 * This is for compatibility only.  The queue is always cleared
620 		 * by NBD_DO_IT or NBD_CLEAR_SOCK.
621 		 */
622 		BUG_ON(!lo->sock && !list_empty(&lo->queue_head));
623 		return 0;
624 	case NBD_PRINT_DEBUG:
625 		printk(KERN_INFO "%s: next = %p, prev = %p, head = %p\n",
626 			inode->i_bdev->bd_disk->disk_name,
627 			lo->queue_head.next, lo->queue_head.prev,
628 			&lo->queue_head);
629 		return 0;
630 	}
631 	return -EINVAL;
632 }
633 
634 static struct block_device_operations nbd_fops =
635 {
636 	.owner =	THIS_MODULE,
637 	.ioctl =	nbd_ioctl,
638 };
639 
640 /*
641  * And here should be modules and kernel interface
642  *  (Just smiley confuses emacs :-)
643  */
644 
645 static int __init nbd_init(void)
646 {
647 	int err = -ENOMEM;
648 	int i;
649 
650 	BUILD_BUG_ON(sizeof(struct nbd_request) != 28);
651 
652 	if (nbds_max > MAX_NBD) {
653 		printk(KERN_CRIT "nbd: cannot allocate more than %u nbds; %u requested.\n", MAX_NBD,
654 				nbds_max);
655 		return -EINVAL;
656 	}
657 
658 	for (i = 0; i < nbds_max; i++) {
659 		struct gendisk *disk = alloc_disk(1);
660 		if (!disk)
661 			goto out;
662 		nbd_dev[i].disk = disk;
663 		/*
664 		 * The new linux 2.5 block layer implementation requires
665 		 * every gendisk to have its very own request_queue struct.
666 		 * These structs are big so we dynamically allocate them.
667 		 */
668 		disk->queue = blk_init_queue(do_nbd_request, &nbd_lock);
669 		if (!disk->queue) {
670 			put_disk(disk);
671 			goto out;
672 		}
673 	}
674 
675 	if (register_blkdev(NBD_MAJOR, "nbd")) {
676 		err = -EIO;
677 		goto out;
678 	}
679 
680 	printk(KERN_INFO "nbd: registered device at major %d\n", NBD_MAJOR);
681 	dprintk(DBG_INIT, "nbd: debugflags=0x%x\n", debugflags);
682 
683 	for (i = 0; i < nbds_max; i++) {
684 		struct gendisk *disk = nbd_dev[i].disk;
685 		nbd_dev[i].file = NULL;
686 		nbd_dev[i].magic = LO_MAGIC;
687 		nbd_dev[i].flags = 0;
688 		spin_lock_init(&nbd_dev[i].queue_lock);
689 		INIT_LIST_HEAD(&nbd_dev[i].queue_head);
690 		mutex_init(&nbd_dev[i].tx_lock);
691 		init_waitqueue_head(&nbd_dev[i].active_wq);
692 		nbd_dev[i].blksize = 1024;
693 		nbd_dev[i].bytesize = 0;
694 		disk->major = NBD_MAJOR;
695 		disk->first_minor = i;
696 		disk->fops = &nbd_fops;
697 		disk->private_data = &nbd_dev[i];
698 		disk->flags |= GENHD_FL_SUPPRESS_PARTITION_INFO;
699 		sprintf(disk->disk_name, "nbd%d", i);
700 		set_capacity(disk, 0);
701 		add_disk(disk);
702 	}
703 
704 	return 0;
705 out:
706 	while (i--) {
707 		blk_cleanup_queue(nbd_dev[i].disk->queue);
708 		put_disk(nbd_dev[i].disk);
709 	}
710 	return err;
711 }
712 
713 static void __exit nbd_cleanup(void)
714 {
715 	int i;
716 	for (i = 0; i < nbds_max; i++) {
717 		struct gendisk *disk = nbd_dev[i].disk;
718 		nbd_dev[i].magic = 0;
719 		if (disk) {
720 			del_gendisk(disk);
721 			blk_cleanup_queue(disk->queue);
722 			put_disk(disk);
723 		}
724 	}
725 	unregister_blkdev(NBD_MAJOR, "nbd");
726 	printk(KERN_INFO "nbd: unregistered device at major %d\n", NBD_MAJOR);
727 }
728 
729 module_init(nbd_init);
730 module_exit(nbd_cleanup);
731 
732 MODULE_DESCRIPTION("Network Block Device");
733 MODULE_LICENSE("GPL");
734 
735 module_param(nbds_max, int, 0444);
736 MODULE_PARM_DESC(nbds_max, "How many network block devices to initialize.");
737 #ifndef NDEBUG
738 module_param(debugflags, int, 0644);
739 MODULE_PARM_DESC(debugflags, "flags for controlling debug output");
740 #endif
741