nbd.c 19.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9
/*
 * Network block device - make block devices work over TCP
 *
 * Note that you can not swap over this thing, yet. Seems to work but
 * deadlocks sometimes - you can not swap over TCP in general.
 * 
 * Copyright 1997-2000 Pavel Machek <pavel@ucw.cz>
 * Parts copyright 2001 Steven Whitehouse <steve@chygwyn.com>
 *
10
 * This file is released under GPLv2 or later.
L
Linus Torvalds 已提交
11
 *
12
 * (part of code stolen from loop.c)
L
Linus Torvalds 已提交
13 14 15 16 17 18 19 20 21 22 23 24 25 26
 */

#include <linux/major.h>

#include <linux/blkdev.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/fs.h>
#include <linux/bio.h>
#include <linux/stat.h>
#include <linux/errno.h>
#include <linux/file.h>
#include <linux/ioctl.h>
27 28 29
#include <linux/compiler.h>
#include <linux/err.h>
#include <linux/kernel.h>
L
Linus Torvalds 已提交
30
#include <net/sock.h>
31
#include <linux/net.h>
32
#include <linux/kthread.h>
L
Linus Torvalds 已提交
33 34

#include <asm/uaccess.h>
35
#include <asm/system.h>
L
Linus Torvalds 已提交
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
#include <asm/types.h>

#include <linux/nbd.h>

#define LO_MAGIC 0x68797548

#ifdef NDEBUG
#define dprintk(flags, fmt...)
#else /* NDEBUG */
#define dprintk(flags, fmt...) do { \
	if (debugflags & (flags)) printk(KERN_DEBUG fmt); \
} while (0)
#define DBG_IOCTL       0x0004
#define DBG_INIT        0x0010
#define DBG_EXIT        0x0020
#define DBG_BLKDEV      0x0100
#define DBG_RX          0x0200
#define DBG_TX          0x0400
static unsigned int debugflags;
#endif /* NDEBUG */

57
static unsigned int nbds_max = 16;
58
static struct nbd_device *nbd_dev;
L
Laurent Vivier 已提交
59
static int max_part;
L
Linus Torvalds 已提交
60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104

/*
 * Use just one lock (or at most 1 per NIC). Two arguments for this:
 * 1. Each NIC is essentially a synchronization point for all servers
 *    accessed through that NIC so there's no need to have more locks
 *    than NICs anyway.
 * 2. More locks lead to more "Dirty cache line bouncing" which will slow
 *    down each lock to the point where they're actually slower than just
 *    a single lock.
 * Thanks go to Jens Axboe and Al Viro for their LKML emails explaining this!
 */
static DEFINE_SPINLOCK(nbd_lock);

#ifndef NDEBUG
static const char *ioctl_cmd_to_ascii(int cmd)
{
	switch (cmd) {
	case NBD_SET_SOCK: return "set-sock";
	case NBD_SET_BLKSIZE: return "set-blksize";
	case NBD_SET_SIZE: return "set-size";
	case NBD_DO_IT: return "do-it";
	case NBD_CLEAR_SOCK: return "clear-sock";
	case NBD_CLEAR_QUE: return "clear-que";
	case NBD_PRINT_DEBUG: return "print-debug";
	case NBD_SET_SIZE_BLOCKS: return "set-size-blocks";
	case NBD_DISCONNECT: return "disconnect";
	case BLKROSET: return "set-read-only";
	case BLKFLSBUF: return "flush-buffer-cache";
	}
	return "unknown";
}

static const char *nbdcmd_to_ascii(int cmd)
{
	switch (cmd) {
	case  NBD_CMD_READ: return "read";
	case NBD_CMD_WRITE: return "write";
	case  NBD_CMD_DISC: return "disconnect";
	}
	return "invalid";
}
#endif /* NDEBUG */

static void nbd_end_request(struct request *req)
{
105
	int error = req->errors ? -EIO : 0;
106
	struct request_queue *q = req->q;
L
Linus Torvalds 已提交
107 108 109
	unsigned long flags;

	dprintk(DBG_BLKDEV, "%s: request %p: %s\n", req->rq_disk->disk_name,
110
			req, error ? "failed" : "done");
L
Linus Torvalds 已提交
111 112

	spin_lock_irqsave(q->queue_lock, flags);
113
	__blk_end_request(req, error, req->nr_sectors << 9);
L
Linus Torvalds 已提交
114 115 116
	spin_unlock_irqrestore(q->queue_lock, flags);
}

117 118 119 120 121 122 123 124 125 126 127 128 129
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);
130
		kernel_sock_shutdown(lo->sock, SHUT_RDWR);
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
		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);
}

L
Linus Torvalds 已提交
146 147 148
/*
 *  Send or receive packet.
 */
149
static int sock_xmit(struct nbd_device *lo, int send, void *buf, int size,
L
Linus Torvalds 已提交
150 151
		int msg_flags)
{
152
	struct socket *sock = lo->sock;
L
Linus Torvalds 已提交
153 154 155
	int result;
	struct msghdr msg;
	struct kvec iov;
156
	sigset_t blocked, oldset;
L
Linus Torvalds 已提交
157

158 159 160 161 162 163
	if (unlikely(!sock)) {
		printk(KERN_ERR "%s: Attempted %s on closed socket in sock_xmit\n",
		       lo->disk->disk_name, (send ? "send" : "recv"));
		return -EINVAL;
	}

L
Linus Torvalds 已提交
164 165
	/* Allow interception of SIGKILL only
	 * Don't allow other signals to interrupt the transmission */
166 167
	siginitsetinv(&blocked, sigmask(SIGKILL));
	sigprocmask(SIG_SETMASK, &blocked, &oldset);
L
Linus Torvalds 已提交
168 169 170 171 172 173 174 175 176 177 178

	do {
		sock->sk->sk_allocation = GFP_NOIO;
		iov.iov_base = buf;
		iov.iov_len = size;
		msg.msg_name = NULL;
		msg.msg_namelen = 0;
		msg.msg_control = NULL;
		msg.msg_controllen = 0;
		msg.msg_flags = msg_flags | MSG_NOSIGNAL;

179 180 181 182 183 184 185 186 187 188
		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);
			}
L
Linus Torvalds 已提交
189
			result = kernel_sendmsg(sock, &msg, &iov, 1, size);
190 191 192
			if (lo->xmit_timeout)
				del_timer_sync(&ti);
		} else
L
Linus Torvalds 已提交
193 194 195 196 197
			result = kernel_recvmsg(sock, &msg, &iov, 1, size, 0);

		if (signal_pending(current)) {
			siginfo_t info;
			printk(KERN_WARNING "nbd (pid %d: %s) got signal %d\n",
198
				task_pid_nr(current), current->comm,
199
				dequeue_signal_lock(current, &current->blocked, &info));
L
Linus Torvalds 已提交
200
			result = -EINTR;
201
			sock_shutdown(lo, !send);
L
Linus Torvalds 已提交
202 203 204 205 206 207 208 209 210 211 212 213
			break;
		}

		if (result <= 0) {
			if (result == 0)
				result = -EPIPE; /* short read */
			break;
		}
		size -= result;
		buf += result;
	} while (size > 0);

214
	sigprocmask(SIG_SETMASK, &oldset, NULL);
L
Linus Torvalds 已提交
215 216 217 218

	return result;
}

219
static inline int sock_send_bvec(struct nbd_device *lo, struct bio_vec *bvec,
L
Linus Torvalds 已提交
220 221 222 223
		int flags)
{
	int result;
	void *kaddr = kmap(bvec->bv_page);
224
	result = sock_xmit(lo, 1, kaddr + bvec->bv_offset, bvec->bv_len, flags);
L
Linus Torvalds 已提交
225 226 227 228
	kunmap(bvec->bv_page);
	return result;
}

229
/* always call with the tx_lock held */
L
Linus Torvalds 已提交
230 231
static int nbd_send_req(struct nbd_device *lo, struct request *req)
{
232
	int result, flags;
L
Linus Torvalds 已提交
233 234 235 236 237 238 239 240 241 242 243 244 245 246
	struct nbd_request request;
	unsigned long size = req->nr_sectors << 9;

	request.magic = htonl(NBD_REQUEST_MAGIC);
	request.type = htonl(nbd_cmd(req));
	request.from = cpu_to_be64((u64) req->sector << 9);
	request.len = htonl(size);
	memcpy(request.handle, &req, sizeof(req));

	dprintk(DBG_TX, "%s: request %p: sending control (%s@%llu,%luB)\n",
			lo->disk->disk_name, req,
			nbdcmd_to_ascii(nbd_cmd(req)),
			(unsigned long long)req->sector << 9,
			req->nr_sectors << 9);
247 248
	result = sock_xmit(lo, 1, &request, sizeof(request),
			(nbd_cmd(req) == NBD_CMD_WRITE) ? MSG_MORE : 0);
L
Linus Torvalds 已提交
249 250 251 252 253 254 255
	if (result <= 0) {
		printk(KERN_ERR "%s: Send control failed (result %d)\n",
				lo->disk->disk_name, result);
		goto error_out;
	}

	if (nbd_cmd(req) == NBD_CMD_WRITE) {
256 257
		struct req_iterator iter;
		struct bio_vec *bvec;
L
Linus Torvalds 已提交
258 259 260 261
		/*
		 * we are really probing at internals to determine
		 * whether to set MSG_MORE or not...
		 */
262
		rq_for_each_segment(bvec, req, iter) {
263 264 265 266 267
			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);
268
			result = sock_send_bvec(lo, bvec, flags);
269 270 271 272 273
			if (result <= 0) {
				printk(KERN_ERR "%s: Send data failed (result %d)\n",
						lo->disk->disk_name, result);
				goto error_out;
			}
L
Linus Torvalds 已提交
274 275 276 277 278 279 280 281
		}
	}
	return 0;

error_out:
	return 1;
}

282 283
static struct request *nbd_find_request(struct nbd_device *lo,
					struct request *xreq)
L
Linus Torvalds 已提交
284
{
285
	struct request *req, *tmp;
286
	int err;
L
Linus Torvalds 已提交
287

288 289 290 291
	err = wait_event_interruptible(lo->active_wq, lo->active_req != xreq);
	if (unlikely(err))
		goto out;

L
Linus Torvalds 已提交
292
	spin_lock(&lo->queue_lock);
293
	list_for_each_entry_safe(req, tmp, &lo->queue_head, queuelist) {
L
Linus Torvalds 已提交
294 295 296 297 298 299 300
		if (req != xreq)
			continue;
		list_del_init(&req->queuelist);
		spin_unlock(&lo->queue_lock);
		return req;
	}
	spin_unlock(&lo->queue_lock);
301 302 303 304 305

	err = -ENOENT;

out:
	return ERR_PTR(err);
L
Linus Torvalds 已提交
306 307
}

308
static inline int sock_recv_bvec(struct nbd_device *lo, struct bio_vec *bvec)
L
Linus Torvalds 已提交
309 310 311
{
	int result;
	void *kaddr = kmap(bvec->bv_page);
312
	result = sock_xmit(lo, 0, kaddr + bvec->bv_offset, bvec->bv_len,
L
Linus Torvalds 已提交
313 314 315 316 317 318 319 320 321 322 323 324 325
			MSG_WAITALL);
	kunmap(bvec->bv_page);
	return result;
}

/* NULL returned = something went wrong, inform userspace */
static struct request *nbd_read_stat(struct nbd_device *lo)
{
	int result;
	struct nbd_reply reply;
	struct request *req;

	reply.magic = 0;
326
	result = sock_xmit(lo, 0, &reply, sizeof(reply), MSG_WAITALL);
L
Linus Torvalds 已提交
327 328 329 330 331
	if (result <= 0) {
		printk(KERN_ERR "%s: Receive control failed (result %d)\n",
				lo->disk->disk_name, result);
		goto harderror;
	}
332 333 334 335 336 337 338 339 340

	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;
	}

341
	req = nbd_find_request(lo, *(struct request **)reply.handle);
342
	if (IS_ERR(req)) {
343 344 345 346
		result = PTR_ERR(req);
		if (result != -ENOENT)
			goto harderror;

L
Linus Torvalds 已提交
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
		printk(KERN_ERR "%s: Unexpected reply (%p)\n",
				lo->disk->disk_name, reply.handle);
		result = -EBADR;
		goto harderror;
	}

	if (ntohl(reply.error)) {
		printk(KERN_ERR "%s: Other side returned error (%d)\n",
				lo->disk->disk_name, ntohl(reply.error));
		req->errors++;
		return req;
	}

	dprintk(DBG_RX, "%s: request %p: got reply\n",
			lo->disk->disk_name, req);
	if (nbd_cmd(req) == NBD_CMD_READ) {
363 364 365 366
		struct req_iterator iter;
		struct bio_vec *bvec;

		rq_for_each_segment(bvec, req, iter) {
367
			result = sock_recv_bvec(lo, bvec);
368 369 370 371 372 373 374 375
			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);
L
Linus Torvalds 已提交
376 377 378 379 380 381 382 383
		}
	}
	return req;
harderror:
	lo->harderror = result;
	return NULL;
}

384 385
static ssize_t pid_show(struct device *dev,
			struct device_attribute *attr, char *buf)
386
{
387 388 389
	struct gendisk *disk = dev_to_disk(dev);

	return sprintf(buf, "%ld\n",
390 391 392
		(long) ((struct nbd_device *)disk->private_data)->pid);
}

393 394
static struct device_attribute pid_attr = {
	.attr = { .name = "pid", .mode = S_IRUGO, .owner = THIS_MODULE },
395 396 397
	.show = pid_show,
};

398
static int nbd_do_it(struct nbd_device *lo)
L
Linus Torvalds 已提交
399 400
{
	struct request *req;
401
	int ret;
L
Linus Torvalds 已提交
402 403 404

	BUG_ON(lo->magic != LO_MAGIC);

405
	lo->pid = current->pid;
406
	ret = sysfs_create_file(&lo->disk->dev.kobj, &pid_attr.attr);
407 408 409 410
	if (ret) {
		printk(KERN_ERR "nbd: sysfs_create_file failed!");
		return ret;
	}
411

L
Linus Torvalds 已提交
412 413
	while ((req = nbd_read_stat(lo)) != NULL)
		nbd_end_request(req);
414

415
	sysfs_remove_file(&lo->disk->dev.kobj, &pid_attr.attr);
416
	return 0;
L
Linus Torvalds 已提交
417 418 419 420 421 422 423 424
}

static void nbd_clear_que(struct nbd_device *lo)
{
	struct request *req;

	BUG_ON(lo->magic != LO_MAGIC);

425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
	/*
	 * Because we have set lo->sock to NULL under the tx_lock, all
	 * modifications to the list must have completed by now.  For
	 * the same reason, the active_req must be NULL.
	 *
	 * As a consequence, we don't need to take the spin lock while
	 * purging the list here.
	 */
	BUG_ON(lo->sock);
	BUG_ON(lo->active_req);

	while (!list_empty(&lo->queue_head)) {
		req = list_entry(lo->queue_head.next, struct request,
				 queuelist);
		list_del_init(&req->queuelist);
		req->errors++;
		nbd_end_request(req);
	}
L
Linus Torvalds 已提交
443 444
}

445

446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
static void nbd_handle_req(struct nbd_device *lo, struct request *req)
{
	if (!blk_fs_request(req))
		goto error_out;

	nbd_cmd(req) = NBD_CMD_READ;
	if (rq_data_dir(req) == WRITE) {
		nbd_cmd(req) = NBD_CMD_WRITE;
		if (lo->flags & NBD_READ_ONLY) {
			printk(KERN_ERR "%s: Write on read-only\n",
					lo->disk->disk_name);
			goto error_out;
		}
	}

	req->errors = 0;

	mutex_lock(&lo->tx_lock);
	if (unlikely(!lo->sock)) {
		mutex_unlock(&lo->tx_lock);
		printk(KERN_ERR "%s: Attempted send on closed socket\n",
		       lo->disk->disk_name);
		req->errors++;
		nbd_end_request(req);
		return;
	}

	lo->active_req = req;

	if (nbd_send_req(lo, req) != 0) {
		printk(KERN_ERR "%s: Request send failed\n",
				lo->disk->disk_name);
		req->errors++;
		nbd_end_request(req);
	} else {
		spin_lock(&lo->queue_lock);
		list_add(&req->queuelist, &lo->queue_head);
		spin_unlock(&lo->queue_lock);
	}

	lo->active_req = NULL;
	mutex_unlock(&lo->tx_lock);
	wake_up_all(&lo->active_wq);

	return;

error_out:
	req->errors++;
	nbd_end_request(req);
}

static int nbd_thread(void *data)
{
	struct nbd_device *lo = data;
	struct request *req;

	set_user_nice(current, -20);
	while (!kthread_should_stop() || !list_empty(&lo->waiting_queue)) {
		/* wait for something to do */
		wait_event_interruptible(lo->waiting_wq,
					 kthread_should_stop() ||
					 !list_empty(&lo->waiting_queue));

		/* extract request */
		if (list_empty(&lo->waiting_queue))
			continue;

		spin_lock_irq(&lo->queue_lock);
		req = list_entry(lo->waiting_queue.next, struct request,
				 queuelist);
		list_del_init(&req->queuelist);
		spin_unlock_irq(&lo->queue_lock);

		/* handle request */
		nbd_handle_req(lo, req);
	}
	return 0;
}

L
Linus Torvalds 已提交
525 526 527
/*
 * We always wait for result of write, for now. It would be nice to make it optional
 * in future
528
 * if ((rq_data_dir(req) == WRITE) && (lo->flags & NBD_WRITE_NOCHK))
L
Linus Torvalds 已提交
529 530 531
 *   { printk( "Warning: Ignoring result!\n"); nbd_end_request( req ); }
 */

532
static void do_nbd_request(struct request_queue * q)
L
Linus Torvalds 已提交
533 534 535 536 537 538 539
{
	struct request *req;
	
	while ((req = elv_next_request(q)) != NULL) {
		struct nbd_device *lo;

		blkdev_dequeue_request(req);
540 541 542

		spin_unlock_irq(q->queue_lock);

543 544
		dprintk(DBG_BLKDEV, "%s: request %p: dequeued (flags=%x)\n",
				req->rq_disk->disk_name, req, req->cmd_type);
L
Linus Torvalds 已提交
545 546 547 548 549

		lo = req->rq_disk->private_data;

		BUG_ON(lo->magic != LO_MAGIC);

550 551 552
		spin_lock_irq(&lo->queue_lock);
		list_add_tail(&req->queuelist, &lo->waiting_queue);
		spin_unlock_irq(&lo->queue_lock);
L
Linus Torvalds 已提交
553

554
		wake_up(&lo->waiting_wq);
555

L
Linus Torvalds 已提交
556 557 558 559 560 561 562 563 564 565
		spin_lock_irq(q->queue_lock);
	}
}

static int nbd_ioctl(struct inode *inode, struct file *file,
		     unsigned int cmd, unsigned long arg)
{
	struct nbd_device *lo = inode->i_bdev->bd_disk->private_data;
	int error;
	struct request sreq ;
566
	struct task_struct *thread;
L
Linus Torvalds 已提交
567 568 569 570 571 572 573 574 575 576 577 578 579

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	BUG_ON(lo->magic != LO_MAGIC);

	/* Anyone capable of this syscall can do *real bad* things */
	dprintk(DBG_IOCTL, "%s: nbd_ioctl cmd=%s(0x%x) arg=%lu\n",
			lo->disk->disk_name, ioctl_cmd_to_ascii(cmd), cmd, arg);

	switch (cmd) {
	case NBD_DISCONNECT:
	        printk(KERN_INFO "%s: NBD_DISCONNECT\n", lo->disk->disk_name);
580
		blk_rq_init(NULL, &sreq);
581
		sreq.cmd_type = REQ_TYPE_SPECIAL;
L
Linus Torvalds 已提交
582 583 584 585 586 587 588 589 590 591
		nbd_cmd(&sreq) = NBD_CMD_DISC;
		/*
		 * Set these to sane values in case server implementation
		 * fails to check the request type first and also to keep
		 * debugging output cleaner.
		 */
		sreq.sector = 0;
		sreq.nr_sectors = 0;
                if (!lo->sock)
			return -EINVAL;
592
		mutex_lock(&lo->tx_lock);
L
Linus Torvalds 已提交
593
                nbd_send_req(lo, &sreq);
594
		mutex_unlock(&lo->tx_lock);
L
Linus Torvalds 已提交
595 596 597 598
                return 0;
 
	case NBD_CLEAR_SOCK:
		error = 0;
599
		mutex_lock(&lo->tx_lock);
L
Linus Torvalds 已提交
600
		lo->sock = NULL;
601
		mutex_unlock(&lo->tx_lock);
L
Linus Torvalds 已提交
602 603 604
		file = lo->file;
		lo->file = NULL;
		nbd_clear_que(lo);
605
		BUG_ON(!list_empty(&lo->queue_head));
L
Linus Torvalds 已提交
606 607 608 609 610 611 612 613 614
		if (file)
			fput(file);
		return error;
	case NBD_SET_SOCK:
		if (lo->file)
			return -EBUSY;
		error = -EINVAL;
		file = fget(arg);
		if (file) {
L
Laurent Vivier 已提交
615
			struct block_device *bdev = inode->i_bdev;
J
Josef Sipek 已提交
616
			inode = file->f_path.dentry->d_inode;
L
Linus Torvalds 已提交
617 618 619
			if (S_ISSOCK(inode->i_mode)) {
				lo->file = file;
				lo->sock = SOCKET_I(inode);
L
Laurent Vivier 已提交
620 621
				if (max_part > 0)
					bdev->bd_invalidated = 1;
L
Linus Torvalds 已提交
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640
				error = 0;
			} else {
				fput(file);
			}
		}
		return error;
	case NBD_SET_BLKSIZE:
		lo->blksize = arg;
		lo->bytesize &= ~(lo->blksize-1);
		inode->i_bdev->bd_inode->i_size = lo->bytesize;
		set_blocksize(inode->i_bdev, lo->blksize);
		set_capacity(lo->disk, lo->bytesize >> 9);
		return 0;
	case NBD_SET_SIZE:
		lo->bytesize = arg & ~(lo->blksize-1);
		inode->i_bdev->bd_inode->i_size = lo->bytesize;
		set_blocksize(inode->i_bdev, lo->blksize);
		set_capacity(lo->disk, lo->bytesize >> 9);
		return 0;
641 642 643
	case NBD_SET_TIMEOUT:
		lo->xmit_timeout = arg * HZ;
		return 0;
L
Linus Torvalds 已提交
644 645 646 647 648 649 650 651 652
	case NBD_SET_SIZE_BLOCKS:
		lo->bytesize = ((u64) arg) * lo->blksize;
		inode->i_bdev->bd_inode->i_size = lo->bytesize;
		set_blocksize(inode->i_bdev, lo->blksize);
		set_capacity(lo->disk, lo->bytesize >> 9);
		return 0;
	case NBD_DO_IT:
		if (!lo->file)
			return -EINVAL;
653 654 655 656
		thread = kthread_create(nbd_thread, lo, lo->disk->disk_name);
		if (IS_ERR(thread))
			return PTR_ERR(thread);
		wake_up_process(thread);
657
		error = nbd_do_it(lo);
658
		kthread_stop(thread);
659 660
		if (error)
			return error;
661
		sock_shutdown(lo, 1);
L
Linus Torvalds 已提交
662 663 664 665 666 667
		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);
668 669 670
		lo->bytesize = 0;
		inode->i_bdev->bd_inode->i_size = 0;
		set_capacity(lo->disk, 0);
L
Laurent Vivier 已提交
671 672
		if (max_part > 0)
			ioctl_by_bdev(inode->i_bdev, BLKRRPART, 0);
L
Linus Torvalds 已提交
673 674
		return lo->harderror;
	case NBD_CLEAR_QUE:
675 676 677 678 679
		/*
		 * This is for compatibility only.  The queue is always cleared
		 * by NBD_DO_IT or NBD_CLEAR_SOCK.
		 */
		BUG_ON(!lo->sock && !list_empty(&lo->queue_head));
L
Linus Torvalds 已提交
680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705
		return 0;
	case NBD_PRINT_DEBUG:
		printk(KERN_INFO "%s: next = %p, prev = %p, head = %p\n",
			inode->i_bdev->bd_disk->disk_name,
			lo->queue_head.next, lo->queue_head.prev,
			&lo->queue_head);
		return 0;
	}
	return -EINVAL;
}

static struct block_device_operations nbd_fops =
{
	.owner =	THIS_MODULE,
	.ioctl =	nbd_ioctl,
};

/*
 * And here should be modules and kernel interface 
 *  (Just smiley confuses emacs :-)
 */

static int __init nbd_init(void)
{
	int err = -ENOMEM;
	int i;
L
Laurent Vivier 已提交
706
	int part_shift;
L
Linus Torvalds 已提交
707

708
	BUILD_BUG_ON(sizeof(struct nbd_request) != 28);
L
Linus Torvalds 已提交
709

L
Laurent Vivier 已提交
710 711 712 713 714
	if (max_part < 0) {
		printk(KERN_CRIT "nbd: max_part must be >= 0\n");
		return -EINVAL;
	}

715 716 717 718
	nbd_dev = kcalloc(nbds_max, sizeof(*nbd_dev), GFP_KERNEL);
	if (!nbd_dev)
		return -ENOMEM;

L
Laurent Vivier 已提交
719 720 721 722
	part_shift = 0;
	if (max_part > 0)
		part_shift = fls(max_part);

723
	for (i = 0; i < nbds_max; i++) {
L
Laurent Vivier 已提交
724
		struct gendisk *disk = alloc_disk(1 << part_shift);
725
		elevator_t *old_e;
L
Linus Torvalds 已提交
726 727 728 729 730 731 732 733 734 735 736 737 738
		if (!disk)
			goto out;
		nbd_dev[i].disk = disk;
		/*
		 * The new linux 2.5 block layer implementation requires
		 * every gendisk to have its very own request_queue struct.
		 * These structs are big so we dynamically allocate them.
		 */
		disk->queue = blk_init_queue(do_nbd_request, &nbd_lock);
		if (!disk->queue) {
			put_disk(disk);
			goto out;
		}
739 740 741 742 743
		old_e = disk->queue->elevator;
		if (elevator_init(disk->queue, "deadline") == 0 ||
			elevator_init(disk->queue, "noop") == 0) {
				elevator_exit(old_e);
		}
L
Linus Torvalds 已提交
744 745 746 747 748 749 750 751 752 753
	}

	if (register_blkdev(NBD_MAJOR, "nbd")) {
		err = -EIO;
		goto out;
	}

	printk(KERN_INFO "nbd: registered device at major %d\n", NBD_MAJOR);
	dprintk(DBG_INIT, "nbd: debugflags=0x%x\n", debugflags);

754
	for (i = 0; i < nbds_max; i++) {
L
Linus Torvalds 已提交
755 756 757 758
		struct gendisk *disk = nbd_dev[i].disk;
		nbd_dev[i].file = NULL;
		nbd_dev[i].magic = LO_MAGIC;
		nbd_dev[i].flags = 0;
759
		INIT_LIST_HEAD(&nbd_dev[i].waiting_queue);
L
Linus Torvalds 已提交
760 761
		spin_lock_init(&nbd_dev[i].queue_lock);
		INIT_LIST_HEAD(&nbd_dev[i].queue_head);
762
		mutex_init(&nbd_dev[i].tx_lock);
763
		init_waitqueue_head(&nbd_dev[i].active_wq);
764
		init_waitqueue_head(&nbd_dev[i].waiting_wq);
L
Linus Torvalds 已提交
765
		nbd_dev[i].blksize = 1024;
766
		nbd_dev[i].bytesize = 0;
L
Linus Torvalds 已提交
767
		disk->major = NBD_MAJOR;
L
Laurent Vivier 已提交
768
		disk->first_minor = i << part_shift;
L
Linus Torvalds 已提交
769 770 771
		disk->fops = &nbd_fops;
		disk->private_data = &nbd_dev[i];
		sprintf(disk->disk_name, "nbd%d", i);
772
		set_capacity(disk, 0);
L
Linus Torvalds 已提交
773 774 775 776 777 778 779 780 781
		add_disk(disk);
	}

	return 0;
out:
	while (i--) {
		blk_cleanup_queue(nbd_dev[i].disk->queue);
		put_disk(nbd_dev[i].disk);
	}
782
	kfree(nbd_dev);
L
Linus Torvalds 已提交
783 784 785 786 787 788
	return err;
}

static void __exit nbd_cleanup(void)
{
	int i;
789
	for (i = 0; i < nbds_max; i++) {
L
Linus Torvalds 已提交
790
		struct gendisk *disk = nbd_dev[i].disk;
791
		nbd_dev[i].magic = 0;
L
Linus Torvalds 已提交
792 793 794 795 796 797 798
		if (disk) {
			del_gendisk(disk);
			blk_cleanup_queue(disk->queue);
			put_disk(disk);
		}
	}
	unregister_blkdev(NBD_MAJOR, "nbd");
799
	kfree(nbd_dev);
L
Linus Torvalds 已提交
800 801 802 803 804 805 806 807 808
	printk(KERN_INFO "nbd: unregistered device at major %d\n", NBD_MAJOR);
}

module_init(nbd_init);
module_exit(nbd_cleanup);

MODULE_DESCRIPTION("Network Block Device");
MODULE_LICENSE("GPL");

809
module_param(nbds_max, int, 0444);
L
Laurent Vivier 已提交
810 811 812
MODULE_PARM_DESC(nbds_max, "number of network block devices to initialize (default: 16)");
module_param(max_part, int, 0444);
MODULE_PARM_DESC(max_part, "number of partitions per device (default: 0)");
L
Linus Torvalds 已提交
813 814 815 816
#ifndef NDEBUG
module_param(debugflags, int, 0644);
MODULE_PARM_DESC(debugflags, "flags for controlling debug output");
#endif