nbd.c 21.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6
/*
 * 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.
 * 
P
Pavel Machek 已提交
7
 * Copyright 1997-2000, 2008 Pavel Machek <pavel@ucw.cz>
L
Linus Torvalds 已提交
8 9
 * 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
#include <linux/mutex.h>
28 29 30
#include <linux/compiler.h>
#include <linux/err.h>
#include <linux/kernel.h>
31
#include <linux/slab.h>
L
Linus Torvalds 已提交
32
#include <net/sock.h>
33
#include <linux/net.h>
34
#include <linux/kthread.h>
M
Markus Pargmann 已提交
35
#include <linux/types.h>
L
Linus Torvalds 已提交
36 37 38 39 40 41

#include <asm/uaccess.h>
#include <asm/types.h>

#include <linux/nbd.h>

42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
struct nbd_device {
	int flags;
	int harderror;		/* Code of hard error			*/
	struct socket * sock;	/* If == NULL, device is not ready, yet	*/
	int magic;

	spinlock_t queue_lock;
	struct list_head queue_head;	/* Requests waiting result */
	struct request *active_req;
	wait_queue_head_t active_wq;
	struct list_head waiting_queue;	/* Requests to be sent */
	wait_queue_head_t waiting_wq;

	struct mutex tx_lock;
	struct gendisk *disk;
	int blksize;
M
Markus Pargmann 已提交
58
	loff_t bytesize;
59 60 61 62 63
	pid_t pid; /* pid of nbd-client, if attached */
	int xmit_timeout;
	int disconnect; /* a disconnect has been requested by user */
};

64
#define NBD_MAGIC 0x68797548
L
Linus Torvalds 已提交
65

66
static unsigned int nbds_max = 16;
67
static struct nbd_device *nbd_dev;
L
Laurent Vivier 已提交
68
static int max_part;
L
Linus Torvalds 已提交
69 70 71 72 73 74 75 76 77 78 79 80 81

/*
 * 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);

82
static inline struct device *nbd_to_dev(struct nbd_device *nbd)
L
Linus Torvalds 已提交
83
{
84
	return disk_to_dev(nbd->disk);
L
Linus Torvalds 已提交
85 86 87 88 89 90 91 92
}

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";
A
Alex Bligh 已提交
93
	case NBD_CMD_FLUSH: return "flush";
P
Paul Clements 已提交
94
	case  NBD_CMD_TRIM: return "trim/discard";
L
Linus Torvalds 已提交
95 96 97 98
	}
	return "invalid";
}

99
static void nbd_end_request(struct nbd_device *nbd, struct request *req)
L
Linus Torvalds 已提交
100
{
101
	int error = req->errors ? -EIO : 0;
102
	struct request_queue *q = req->q;
L
Linus Torvalds 已提交
103 104
	unsigned long flags;

105 106
	dev_dbg(nbd_to_dev(nbd), "request %p: %s\n", req,
		error ? "failed" : "done");
L
Linus Torvalds 已提交
107 108

	spin_lock_irqsave(q->queue_lock, flags);
109
	__blk_end_request_all(req, error);
L
Linus Torvalds 已提交
110 111 112
	spin_unlock_irqrestore(q->queue_lock, flags);
}

113 114 115
/*
 * Forcibly shutdown the socket causing all listeners to error
 */
116
static void sock_shutdown(struct nbd_device *nbd, int lock)
117 118
{
	if (lock)
119 120 121 122 123
		mutex_lock(&nbd->tx_lock);
	if (nbd->sock) {
		dev_warn(disk_to_dev(nbd->disk), "shutting down socket\n");
		kernel_sock_shutdown(nbd->sock, SHUT_RDWR);
		nbd->sock = NULL;
124 125
	}
	if (lock)
126
		mutex_unlock(&nbd->tx_lock);
127 128 129 130 131 132 133 134 135 136 137
}

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 已提交
138 139 140
/*
 *  Send or receive packet.
 */
141
static int sock_xmit(struct nbd_device *nbd, int send, void *buf, int size,
L
Linus Torvalds 已提交
142 143
		int msg_flags)
{
144
	struct socket *sock = nbd->sock;
L
Linus Torvalds 已提交
145 146 147
	int result;
	struct msghdr msg;
	struct kvec iov;
148
	sigset_t blocked, oldset;
149
	unsigned long pflags = current->flags;
L
Linus Torvalds 已提交
150

151
	if (unlikely(!sock)) {
152
		dev_err(disk_to_dev(nbd->disk),
153 154
			"Attempted %s on closed socket in sock_xmit\n",
			(send ? "send" : "recv"));
155 156 157
		return -EINVAL;
	}

L
Linus Torvalds 已提交
158 159
	/* Allow interception of SIGKILL only
	 * Don't allow other signals to interrupt the transmission */
160 161
	siginitsetinv(&blocked, sigmask(SIGKILL));
	sigprocmask(SIG_SETMASK, &blocked, &oldset);
L
Linus Torvalds 已提交
162

163
	current->flags |= PF_MEMALLOC;
L
Linus Torvalds 已提交
164
	do {
165
		sock->sk->sk_allocation = GFP_NOIO | __GFP_MEMALLOC;
L
Linus Torvalds 已提交
166 167 168 169 170 171 172 173
		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;

174 175 176
		if (send) {
			struct timer_list ti;

177
			if (nbd->xmit_timeout) {
178 179 180
				init_timer(&ti);
				ti.function = nbd_xmit_timeout;
				ti.data = (unsigned long)current;
181
				ti.expires = jiffies + nbd->xmit_timeout;
182 183
				add_timer(&ti);
			}
L
Linus Torvalds 已提交
184
			result = kernel_sendmsg(sock, &msg, &iov, 1, size);
185
			if (nbd->xmit_timeout)
186 187
				del_timer_sync(&ti);
		} else
188 189
			result = kernel_recvmsg(sock, &msg, &iov, 1, size,
						msg.msg_flags);
L
Linus Torvalds 已提交
190 191 192 193

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

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

210
	sigprocmask(SIG_SETMASK, &oldset, NULL);
211
	tsk_restore_flags(current, pflags, PF_MEMALLOC);
L
Linus Torvalds 已提交
212 213 214 215

	return result;
}

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

227
/* always call with the tx_lock held */
228
static int nbd_send_req(struct nbd_device *nbd, struct request *req)
L
Linus Torvalds 已提交
229
{
230
	int result, flags;
L
Linus Torvalds 已提交
231
	struct nbd_request request;
232
	unsigned long size = blk_rq_bytes(req);
C
Christoph Hellwig 已提交
233 234 235 236 237 238 239 240 241 242 243 244
	u32 type;

	if (req->cmd_type == REQ_TYPE_DRV_PRIV)
		type = NBD_CMD_DISC;
	else if (req->cmd_flags & REQ_DISCARD)
		type = NBD_CMD_TRIM;
	else if (req->cmd_flags & REQ_FLUSH)
		type = NBD_CMD_FLUSH;
	else if (rq_data_dir(req) == WRITE)
		type = NBD_CMD_WRITE;
	else
		type = NBD_CMD_READ;
L
Linus Torvalds 已提交
245

246
	memset(&request, 0, sizeof(request));
L
Linus Torvalds 已提交
247
	request.magic = htonl(NBD_REQUEST_MAGIC);
C
Christoph Hellwig 已提交
248 249
	request.type = htonl(type);
	if (type != NBD_CMD_FLUSH && type != NBD_CMD_DISC) {
A
Alex Bligh 已提交
250 251 252
		request.from = cpu_to_be64((u64)blk_rq_pos(req) << 9);
		request.len = htonl(size);
	}
L
Linus Torvalds 已提交
253 254
	memcpy(request.handle, &req, sizeof(req));

255
	dev_dbg(nbd_to_dev(nbd), "request %p: sending control (%s@%llu,%uB)\n",
C
Christoph Hellwig 已提交
256
		req, nbdcmd_to_ascii(type),
257
		(unsigned long long)blk_rq_pos(req) << 9, blk_rq_bytes(req));
258
	result = sock_xmit(nbd, 1, &request, sizeof(request),
C
Christoph Hellwig 已提交
259
			(type == NBD_CMD_WRITE) ? MSG_MORE : 0);
L
Linus Torvalds 已提交
260
	if (result <= 0) {
261
		dev_err(disk_to_dev(nbd->disk),
262
			"Send control failed (result %d)\n", result);
263
		return -EIO;
L
Linus Torvalds 已提交
264 265
	}

C
Christoph Hellwig 已提交
266
	if (type == NBD_CMD_WRITE) {
267
		struct req_iterator iter;
268
		struct bio_vec bvec;
L
Linus Torvalds 已提交
269 270 271 272
		/*
		 * we are really probing at internals to determine
		 * whether to set MSG_MORE or not...
		 */
273
		rq_for_each_segment(bvec, req, iter) {
274
			flags = 0;
K
Kent Overstreet 已提交
275
			if (!rq_iter_last(bvec, iter))
276
				flags = MSG_MORE;
277 278
			dev_dbg(nbd_to_dev(nbd), "request %p: sending %d bytes data\n",
				req, bvec.bv_len);
279
			result = sock_send_bvec(nbd, &bvec, flags);
280
			if (result <= 0) {
281
				dev_err(disk_to_dev(nbd->disk),
282 283
					"Send data failed (result %d)\n",
					result);
284
				return -EIO;
285
			}
L
Linus Torvalds 已提交
286 287 288 289 290
		}
	}
	return 0;
}

291
static struct request *nbd_find_request(struct nbd_device *nbd,
292
					struct request *xreq)
L
Linus Torvalds 已提交
293
{
294
	struct request *req, *tmp;
295
	int err;
L
Linus Torvalds 已提交
296

297
	err = wait_event_interruptible(nbd->active_wq, nbd->active_req != xreq);
298
	if (unlikely(err))
299
		return ERR_PTR(err);
300

301 302
	spin_lock(&nbd->queue_lock);
	list_for_each_entry_safe(req, tmp, &nbd->queue_head, queuelist) {
L
Linus Torvalds 已提交
303 304 305
		if (req != xreq)
			continue;
		list_del_init(&req->queuelist);
306
		spin_unlock(&nbd->queue_lock);
L
Linus Torvalds 已提交
307 308
		return req;
	}
309
	spin_unlock(&nbd->queue_lock);
310

311
	return ERR_PTR(-ENOENT);
L
Linus Torvalds 已提交
312 313
}

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

/* NULL returned = something went wrong, inform userspace */
325
static struct request *nbd_read_stat(struct nbd_device *nbd)
L
Linus Torvalds 已提交
326 327 328 329 330 331
{
	int result;
	struct nbd_reply reply;
	struct request *req;

	reply.magic = 0;
332
	result = sock_xmit(nbd, 0, &reply, sizeof(reply), MSG_WAITALL);
L
Linus Torvalds 已提交
333
	if (result <= 0) {
334
		dev_err(disk_to_dev(nbd->disk),
335
			"Receive control failed (result %d)\n", result);
L
Linus Torvalds 已提交
336 337
		goto harderror;
	}
338 339

	if (ntohl(reply.magic) != NBD_REPLY_MAGIC) {
340
		dev_err(disk_to_dev(nbd->disk), "Wrong magic (0x%lx)\n",
341 342 343 344 345
				(unsigned long)ntohl(reply.magic));
		result = -EPROTO;
		goto harderror;
	}

346
	req = nbd_find_request(nbd, *(struct request **)reply.handle);
347
	if (IS_ERR(req)) {
348 349 350 351
		result = PTR_ERR(req);
		if (result != -ENOENT)
			goto harderror;

352
		dev_err(disk_to_dev(nbd->disk), "Unexpected reply (%p)\n",
353
			reply.handle);
L
Linus Torvalds 已提交
354 355 356 357 358
		result = -EBADR;
		goto harderror;
	}

	if (ntohl(reply.error)) {
359
		dev_err(disk_to_dev(nbd->disk), "Other side returned error (%d)\n",
360
			ntohl(reply.error));
L
Linus Torvalds 已提交
361 362 363 364
		req->errors++;
		return req;
	}

365
	dev_dbg(nbd_to_dev(nbd), "request %p: got reply\n", req);
C
Christoph Hellwig 已提交
366
	if (rq_data_dir(req) != WRITE) {
367
		struct req_iterator iter;
368
		struct bio_vec bvec;
369 370

		rq_for_each_segment(bvec, req, iter) {
371
			result = sock_recv_bvec(nbd, &bvec);
372
			if (result <= 0) {
373
				dev_err(disk_to_dev(nbd->disk), "Receive data failed (result %d)\n",
374
					result);
375 376 377
				req->errors++;
				return req;
			}
378 379
			dev_dbg(nbd_to_dev(nbd), "request %p: got %d bytes data\n",
				req, bvec.bv_len);
L
Linus Torvalds 已提交
380 381 382 383
		}
	}
	return req;
harderror:
384
	nbd->harderror = result;
L
Linus Torvalds 已提交
385 386 387
	return NULL;
}

388 389
static ssize_t pid_show(struct device *dev,
			struct device_attribute *attr, char *buf)
390
{
391 392 393
	struct gendisk *disk = dev_to_disk(dev);

	return sprintf(buf, "%ld\n",
394 395 396
		(long) ((struct nbd_device *)disk->private_data)->pid);
}

397
static struct device_attribute pid_attr = {
398
	.attr = { .name = "pid", .mode = S_IRUGO},
399 400 401
	.show = pid_show,
};

402
static int nbd_do_it(struct nbd_device *nbd)
L
Linus Torvalds 已提交
403 404
{
	struct request *req;
405
	int ret;
L
Linus Torvalds 已提交
406

407
	BUG_ON(nbd->magic != NBD_MAGIC);
L
Linus Torvalds 已提交
408

409
	sk_set_memalloc(nbd->sock->sk);
410 411
	nbd->pid = task_pid_nr(current);
	ret = device_create_file(disk_to_dev(nbd->disk), &pid_attr);
412
	if (ret) {
413 414
		dev_err(disk_to_dev(nbd->disk), "device_create_file failed!\n");
		nbd->pid = 0;
415 416
		return ret;
	}
417

418
	while ((req = nbd_read_stat(nbd)) != NULL)
419
		nbd_end_request(nbd, req);
420

421 422
	device_remove_file(disk_to_dev(nbd->disk), &pid_attr);
	nbd->pid = 0;
423
	return 0;
L
Linus Torvalds 已提交
424 425
}

426
static void nbd_clear_que(struct nbd_device *nbd)
L
Linus Torvalds 已提交
427 428 429
{
	struct request *req;

430
	BUG_ON(nbd->magic != NBD_MAGIC);
L
Linus Torvalds 已提交
431

432
	/*
433
	 * Because we have set nbd->sock to NULL under the tx_lock, all
434 435 436 437 438 439
	 * 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.
	 */
440 441
	BUG_ON(nbd->sock);
	BUG_ON(nbd->active_req);
442

443 444
	while (!list_empty(&nbd->queue_head)) {
		req = list_entry(nbd->queue_head.next, struct request,
445 446 447
				 queuelist);
		list_del_init(&req->queuelist);
		req->errors++;
448
		nbd_end_request(nbd, req);
449
	}
450 451 452 453 454 455

	while (!list_empty(&nbd->waiting_queue)) {
		req = list_entry(nbd->waiting_queue.next, struct request,
				 queuelist);
		list_del_init(&req->queuelist);
		req->errors++;
456
		nbd_end_request(nbd, req);
457
	}
L
Linus Torvalds 已提交
458 459
}

460

461
static void nbd_handle_req(struct nbd_device *nbd, struct request *req)
462
{
463
	if (req->cmd_type != REQ_TYPE_FS)
464 465
		goto error_out;

C
Christoph Hellwig 已提交
466 467 468 469 470
	if (rq_data_dir(req) == WRITE &&
	    (nbd->flags & NBD_FLAG_READ_ONLY)) {
		dev_err(disk_to_dev(nbd->disk),
			"Write on read-only\n");
		goto error_out;
A
Alex Bligh 已提交
471 472
	}

473 474
	req->errors = 0;

475 476 477 478
	mutex_lock(&nbd->tx_lock);
	if (unlikely(!nbd->sock)) {
		mutex_unlock(&nbd->tx_lock);
		dev_err(disk_to_dev(nbd->disk),
479
			"Attempted send on closed socket\n");
P
Pavel Machek 已提交
480
		goto error_out;
481 482
	}

483
	nbd->active_req = req;
484

485 486
	if (nbd_send_req(nbd, req) != 0) {
		dev_err(disk_to_dev(nbd->disk), "Request send failed\n");
487
		req->errors++;
488
		nbd_end_request(nbd, req);
489
	} else {
490
		spin_lock(&nbd->queue_lock);
491
		list_add_tail(&req->queuelist, &nbd->queue_head);
492
		spin_unlock(&nbd->queue_lock);
493 494
	}

495 496 497
	nbd->active_req = NULL;
	mutex_unlock(&nbd->tx_lock);
	wake_up_all(&nbd->active_wq);
498 499 500 501 502

	return;

error_out:
	req->errors++;
503
	nbd_end_request(nbd, req);
504 505 506 507
}

static int nbd_thread(void *data)
{
508
	struct nbd_device *nbd = data;
509 510
	struct request *req;

511
	set_user_nice(current, MIN_NICE);
512
	while (!kthread_should_stop() || !list_empty(&nbd->waiting_queue)) {
513
		/* wait for something to do */
514
		wait_event_interruptible(nbd->waiting_wq,
515
					 kthread_should_stop() ||
516
					 !list_empty(&nbd->waiting_queue));
517 518

		/* extract request */
519
		if (list_empty(&nbd->waiting_queue))
520 521
			continue;

522 523
		spin_lock_irq(&nbd->queue_lock);
		req = list_entry(nbd->waiting_queue.next, struct request,
524 525
				 queuelist);
		list_del_init(&req->queuelist);
526
		spin_unlock_irq(&nbd->queue_lock);
527 528

		/* handle request */
529
		nbd_handle_req(nbd, req);
530 531 532 533
	}
	return 0;
}

L
Linus Torvalds 已提交
534 535 536
/*
 * We always wait for result of write, for now. It would be nice to make it optional
 * in future
537
 * if ((rq_data_dir(req) == WRITE) && (nbd->flags & NBD_WRITE_NOCHK))
L
Linus Torvalds 已提交
538 539 540
 *   { printk( "Warning: Ignoring result!\n"); nbd_end_request( req ); }
 */

P
Pavel Machek 已提交
541
static void do_nbd_request(struct request_queue *q)
A
Alex Elder 已提交
542
		__releases(q->queue_lock) __acquires(q->queue_lock)
L
Linus Torvalds 已提交
543 544 545
{
	struct request *req;
	
546
	while ((req = blk_fetch_request(q)) != NULL) {
547
		struct nbd_device *nbd;
L
Linus Torvalds 已提交
548

549 550
		spin_unlock_irq(q->queue_lock);

551
		nbd = req->rq_disk->private_data;
L
Linus Torvalds 已提交
552

553
		BUG_ON(nbd->magic != NBD_MAGIC);
L
Linus Torvalds 已提交
554

555 556 557
		dev_dbg(nbd_to_dev(nbd), "request %p: dequeued (flags=%x)\n",
			req, req->cmd_type);

558 559
		if (unlikely(!nbd->sock)) {
			dev_err(disk_to_dev(nbd->disk),
560
				"Attempted send on closed socket\n");
561
			req->errors++;
562
			nbd_end_request(nbd, req);
563 564 565 566
			spin_lock_irq(q->queue_lock);
			continue;
		}

567 568 569
		spin_lock_irq(&nbd->queue_lock);
		list_add_tail(&req->queuelist, &nbd->waiting_queue);
		spin_unlock_irq(&nbd->queue_lock);
L
Linus Torvalds 已提交
570

571
		wake_up(&nbd->waiting_wq);
572

L
Linus Torvalds 已提交
573 574 575 576
		spin_lock_irq(q->queue_lock);
	}
}

P
Pavel Machek 已提交
577
/* Must be called with tx_lock held */
L
Linus Torvalds 已提交
578

579
static int __nbd_ioctl(struct block_device *bdev, struct nbd_device *nbd,
P
Pavel Machek 已提交
580 581
		       unsigned int cmd, unsigned long arg)
{
L
Linus Torvalds 已提交
582
	switch (cmd) {
P
Pavel Machek 已提交
583 584 585
	case NBD_DISCONNECT: {
		struct request sreq;

586
		dev_info(disk_to_dev(nbd->disk), "NBD_DISCONNECT\n");
587 588
		if (!nbd->sock)
			return -EINVAL;
P
Pavel Machek 已提交
589

590 591 592
		mutex_unlock(&nbd->tx_lock);
		fsync_bdev(bdev);
		mutex_lock(&nbd->tx_lock);
593
		blk_rq_init(NULL, &sreq);
594
		sreq.cmd_type = REQ_TYPE_DRV_PRIV;
595 596

		/* Check again after getting mutex back.  */
597
		if (!nbd->sock)
L
Linus Torvalds 已提交
598
			return -EINVAL;
599

P
Paul Clements 已提交
600 601
		nbd->disconnect = 1;

602
		nbd_send_req(nbd, &sreq);
P
Paul Clements 已提交
603
		return 0;
P
Pavel Machek 已提交
604
	}
L
Linus Torvalds 已提交
605
 
P
Pavel Machek 已提交
606
	case NBD_CLEAR_SOCK: {
A
Al Viro 已提交
607
		struct socket *sock = nbd->sock;
608 609 610
		nbd->sock = NULL;
		nbd_clear_que(nbd);
		BUG_ON(!list_empty(&nbd->queue_head));
611
		BUG_ON(!list_empty(&nbd->waiting_queue));
612
		kill_bdev(bdev);
A
Al Viro 已提交
613 614
		if (sock)
			sockfd_put(sock);
P
Pavel Machek 已提交
615 616 617 618
		return 0;
	}

	case NBD_SET_SOCK: {
A
Al Viro 已提交
619 620 621
		struct socket *sock;
		int err;
		if (nbd->sock)
L
Linus Torvalds 已提交
622
			return -EBUSY;
A
Al Viro 已提交
623 624 625 626 627 628 629
		sock = sockfd_lookup(arg, &err);
		if (sock) {
			nbd->sock = sock;
			if (max_part > 0)
				bdev->bd_invalidated = 1;
			nbd->disconnect = 0; /* we're connected now */
			return 0;
L
Linus Torvalds 已提交
630
		}
P
Pavel Machek 已提交
631 632 633
		return -EINVAL;
	}

L
Linus Torvalds 已提交
634
	case NBD_SET_BLKSIZE:
635 636 637 638 639
		nbd->blksize = arg;
		nbd->bytesize &= ~(nbd->blksize-1);
		bdev->bd_inode->i_size = nbd->bytesize;
		set_blocksize(bdev, nbd->blksize);
		set_capacity(nbd->disk, nbd->bytesize >> 9);
L
Linus Torvalds 已提交
640
		return 0;
P
Pavel Machek 已提交
641

L
Linus Torvalds 已提交
642
	case NBD_SET_SIZE:
643 644 645 646
		nbd->bytesize = arg & ~(nbd->blksize-1);
		bdev->bd_inode->i_size = nbd->bytesize;
		set_blocksize(bdev, nbd->blksize);
		set_capacity(nbd->disk, nbd->bytesize >> 9);
L
Linus Torvalds 已提交
647
		return 0;
P
Pavel Machek 已提交
648

649
	case NBD_SET_TIMEOUT:
650
		nbd->xmit_timeout = arg * HZ;
651
		return 0;
P
Pavel Machek 已提交
652

P
Paul Clements 已提交
653 654 655 656
	case NBD_SET_FLAGS:
		nbd->flags = arg;
		return 0;

L
Linus Torvalds 已提交
657
	case NBD_SET_SIZE_BLOCKS:
658 659 660 661
		nbd->bytesize = ((u64) arg) * nbd->blksize;
		bdev->bd_inode->i_size = nbd->bytesize;
		set_blocksize(bdev, nbd->blksize);
		set_capacity(nbd->disk, nbd->bytesize >> 9);
L
Linus Torvalds 已提交
662
		return 0;
P
Pavel Machek 已提交
663 664 665

	case NBD_DO_IT: {
		struct task_struct *thread;
A
Al Viro 已提交
666
		struct socket *sock;
P
Pavel Machek 已提交
667 668
		int error;

669
		if (nbd->pid)
670
			return -EBUSY;
A
Al Viro 已提交
671
		if (!nbd->sock)
L
Linus Torvalds 已提交
672
			return -EINVAL;
P
Pavel Machek 已提交
673

674
		mutex_unlock(&nbd->tx_lock);
P
Pavel Machek 已提交
675

676 677
		if (nbd->flags & NBD_FLAG_READ_ONLY)
			set_device_ro(bdev, true);
P
Paul Clements 已提交
678 679 680
		if (nbd->flags & NBD_FLAG_SEND_TRIM)
			queue_flag_set_unlocked(QUEUE_FLAG_DISCARD,
				nbd->disk->queue);
A
Alex Bligh 已提交
681 682 683 684
		if (nbd->flags & NBD_FLAG_SEND_FLUSH)
			blk_queue_flush(nbd->disk->queue, REQ_FLUSH);
		else
			blk_queue_flush(nbd->disk->queue, 0);
P
Paul Clements 已提交
685

686 687
		thread = kthread_run(nbd_thread, nbd, "%s",
				     nbd->disk->disk_name);
P
Pavel Machek 已提交
688
		if (IS_ERR(thread)) {
689
			mutex_lock(&nbd->tx_lock);
690
			return PTR_ERR(thread);
P
Pavel Machek 已提交
691
		}
692

693
		error = nbd_do_it(nbd);
694
		kthread_stop(thread);
P
Pavel Machek 已提交
695

696
		mutex_lock(&nbd->tx_lock);
697 698
		if (error)
			return error;
699
		sock_shutdown(nbd, 0);
A
Al Viro 已提交
700 701
		sock = nbd->sock;
		nbd->sock = NULL;
702 703
		nbd_clear_que(nbd);
		dev_warn(disk_to_dev(nbd->disk), "queue cleared\n");
704
		kill_bdev(bdev);
P
Paul Clements 已提交
705
		queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, nbd->disk->queue);
706
		set_device_ro(bdev, false);
A
Al Viro 已提交
707 708
		if (sock)
			sockfd_put(sock);
A
Alex Bligh 已提交
709
		nbd->flags = 0;
710
		nbd->bytesize = 0;
A
Al Viro 已提交
711
		bdev->bd_inode->i_size = 0;
712
		set_capacity(nbd->disk, 0);
L
Laurent Vivier 已提交
713
		if (max_part > 0)
714
			blkdev_reread_part(bdev);
P
Paul Clements 已提交
715 716
		if (nbd->disconnect) /* user requested, ignore socket errors */
			return 0;
717
		return nbd->harderror;
P
Pavel Machek 已提交
718 719
	}

L
Linus Torvalds 已提交
720
	case NBD_CLEAR_QUE:
721 722 723 724
		/*
		 * This is for compatibility only.  The queue is always cleared
		 * by NBD_DO_IT or NBD_CLEAR_SOCK.
		 */
L
Linus Torvalds 已提交
725
		return 0;
P
Pavel Machek 已提交
726

L
Linus Torvalds 已提交
727
	case NBD_PRINT_DEBUG:
728
		dev_info(disk_to_dev(nbd->disk),
729
			"next = %p, prev = %p, head = %p\n",
730 731
			nbd->queue_head.next, nbd->queue_head.prev,
			&nbd->queue_head);
L
Linus Torvalds 已提交
732 733
		return 0;
	}
P
Pavel Machek 已提交
734 735 736 737 738 739
	return -ENOTTY;
}

static int nbd_ioctl(struct block_device *bdev, fmode_t mode,
		     unsigned int cmd, unsigned long arg)
{
740
	struct nbd_device *nbd = bdev->bd_disk->private_data;
P
Pavel Machek 已提交
741 742 743 744 745
	int error;

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

746
	BUG_ON(nbd->magic != NBD_MAGIC);
P
Pavel Machek 已提交
747

748 749 750
	mutex_lock(&nbd->tx_lock);
	error = __nbd_ioctl(bdev, nbd, cmd, arg);
	mutex_unlock(&nbd->tx_lock);
P
Pavel Machek 已提交
751 752

	return error;
L
Linus Torvalds 已提交
753 754
}

755
static const struct block_device_operations nbd_fops =
L
Linus Torvalds 已提交
756 757
{
	.owner =	THIS_MODULE,
758
	.ioctl =	nbd_ioctl,
L
Linus Torvalds 已提交
759 760 761 762 763 764 765 766 767 768 769
};

/*
 * 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 已提交
770
	int part_shift;
L
Linus Torvalds 已提交
771

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

L
Laurent Vivier 已提交
774
	if (max_part < 0) {
775
		printk(KERN_ERR "nbd: max_part must be >= 0\n");
L
Laurent Vivier 已提交
776 777 778 779
		return -EINVAL;
	}

	part_shift = 0;
780
	if (max_part > 0) {
L
Laurent Vivier 已提交
781 782
		part_shift = fls(max_part);

783 784 785 786 787 788 789 790 791 792 793
		/*
		 * Adjust max_part according to part_shift as it is exported
		 * to user space so that user can know the max number of
		 * partition kernel should be able to manage.
		 *
		 * Note that -1 is required because partition 0 is reserved
		 * for the whole disk.
		 */
		max_part = (1UL << part_shift) - 1;
	}

794 795 796 797 798 799
	if ((1UL << part_shift) > DISK_MAX_PARTS)
		return -EINVAL;

	if (nbds_max > 1UL << (MINORBITS - part_shift))
		return -EINVAL;

S
Sudip Mukherjee 已提交
800 801 802 803
	nbd_dev = kcalloc(nbds_max, sizeof(*nbd_dev), GFP_KERNEL);
	if (!nbd_dev)
		return -ENOMEM;

804
	for (i = 0; i < nbds_max; i++) {
L
Laurent Vivier 已提交
805
		struct gendisk *disk = alloc_disk(1 << part_shift);
L
Linus Torvalds 已提交
806 807 808 809 810 811 812 813 814 815 816 817 818
		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;
		}
819 820 821 822
		/*
		 * Tell the block layer that we are not a rotational device
		 */
		queue_flag_set_unlocked(QUEUE_FLAG_NONROT, disk->queue);
823
		queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, disk->queue);
P
Paul Clements 已提交
824 825 826
		disk->queue->limits.discard_granularity = 512;
		disk->queue->limits.max_discard_sectors = UINT_MAX;
		disk->queue->limits.discard_zeroes_data = 0;
827 828
		blk_queue_max_hw_sectors(disk->queue, 65536);
		disk->queue->limits.max_sectors = 256;
L
Linus Torvalds 已提交
829 830 831 832 833 834 835 836 837
	}

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

	printk(KERN_INFO "nbd: registered device at major %d\n", NBD_MAJOR);

838
	for (i = 0; i < nbds_max; i++) {
L
Linus Torvalds 已提交
839
		struct gendisk *disk = nbd_dev[i].disk;
840
		nbd_dev[i].magic = NBD_MAGIC;
841
		INIT_LIST_HEAD(&nbd_dev[i].waiting_queue);
L
Linus Torvalds 已提交
842 843
		spin_lock_init(&nbd_dev[i].queue_lock);
		INIT_LIST_HEAD(&nbd_dev[i].queue_head);
844
		mutex_init(&nbd_dev[i].tx_lock);
845
		init_waitqueue_head(&nbd_dev[i].active_wq);
846
		init_waitqueue_head(&nbd_dev[i].waiting_wq);
L
Linus Torvalds 已提交
847
		nbd_dev[i].blksize = 1024;
848
		nbd_dev[i].bytesize = 0;
L
Linus Torvalds 已提交
849
		disk->major = NBD_MAJOR;
L
Laurent Vivier 已提交
850
		disk->first_minor = i << part_shift;
L
Linus Torvalds 已提交
851 852 853
		disk->fops = &nbd_fops;
		disk->private_data = &nbd_dev[i];
		sprintf(disk->disk_name, "nbd%d", i);
854
		set_capacity(disk, 0);
L
Linus Torvalds 已提交
855 856 857 858 859 860 861 862 863
		add_disk(disk);
	}

	return 0;
out:
	while (i--) {
		blk_cleanup_queue(nbd_dev[i].disk->queue);
		put_disk(nbd_dev[i].disk);
	}
864
	kfree(nbd_dev);
L
Linus Torvalds 已提交
865 866 867 868 869 870
	return err;
}

static void __exit nbd_cleanup(void)
{
	int i;
871
	for (i = 0; i < nbds_max; i++) {
L
Linus Torvalds 已提交
872
		struct gendisk *disk = nbd_dev[i].disk;
873
		nbd_dev[i].magic = 0;
L
Linus Torvalds 已提交
874 875 876 877 878 879 880
		if (disk) {
			del_gendisk(disk);
			blk_cleanup_queue(disk->queue);
			put_disk(disk);
		}
	}
	unregister_blkdev(NBD_MAJOR, "nbd");
881
	kfree(nbd_dev);
L
Linus Torvalds 已提交
882 883 884 885 886 887 888 889 890
	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");

891
module_param(nbds_max, int, 0444);
L
Laurent Vivier 已提交
892 893 894
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)");