Kernel

Kernel Git Source Tree

Root/drivers/block/nbd.c

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

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/drivers/block/nbd.c

interactive