2 * Network block device - make block devices work over TCP
4 * Note that you can not swap over this thing, yet. Seems to work but
5 * deadlocks sometimes - you can not swap over TCP in general.
7 * Copyright 1997-2000, 2008 Pavel Machek <pavel@ucw.cz>
8 * Parts copyright 2001 Steven Whitehouse <steve@chygwyn.com>
10 * This file is released under GPLv2 or later.
12 * (part of code stolen from loop.c)
15 #include <linux/major.h>
17 #include <linux/blkdev.h>
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/sched.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>
33 #include <linux/net.h>
34 #include <linux/kthread.h>
36 #include <asm/uaccess.h>
37 #include <asm/types.h>
39 #include <linux/nbd.h>
41 #define NBD_MAGIC 0x68797548
44 #define dprintk(flags, fmt...)
46 #define dprintk(flags, fmt...) do { \
47 if (debugflags & (flags)) printk(KERN_DEBUG fmt); \
49 #define DBG_IOCTL 0x0004
50 #define DBG_INIT 0x0010
51 #define DBG_EXIT 0x0020
52 #define DBG_BLKDEV 0x0100
55 static unsigned int debugflags
;
58 static unsigned int nbds_max
= 16;
59 static struct nbd_device
*nbd_dev
;
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
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
70 * Thanks go to Jens Axboe and Al Viro for their LKML emails explaining this!
72 static DEFINE_SPINLOCK(nbd_lock
);
75 static const char *ioctl_cmd_to_ascii(int 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";
93 static const char *nbdcmd_to_ascii(int cmd
)
96 case NBD_CMD_READ
: return "read";
97 case NBD_CMD_WRITE
: return "write";
98 case NBD_CMD_DISC
: return "disconnect";
104 static void nbd_end_request(struct request
*req
)
106 int error
= req
->errors
? -EIO
: 0;
107 struct request_queue
*q
= req
->q
;
110 dprintk(DBG_BLKDEV
, "%s: request %p: %s\n", req
->rq_disk
->disk_name
,
111 req
, error
? "failed" : "done");
113 spin_lock_irqsave(q
->queue_lock
, flags
);
114 __blk_end_request_all(req
, error
);
115 spin_unlock_irqrestore(q
->queue_lock
, flags
);
118 static void sock_shutdown(struct nbd_device
*nbd
, int lock
)
120 /* Forcibly shutdown the socket causing all listeners
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 */
127 mutex_lock(&nbd
->tx_lock
);
129 dev_warn(disk_to_dev(nbd
->disk
), "shutting down socket\n");
130 kernel_sock_shutdown(nbd
->sock
, SHUT_RDWR
);
134 mutex_unlock(&nbd
->tx_lock
);
137 static void nbd_xmit_timeout(unsigned long arg
)
139 struct task_struct
*task
= (struct task_struct
*)arg
;
141 printk(KERN_WARNING
"nbd: killing hung xmit (%s, pid: %d)\n",
142 task
->comm
, task
->pid
);
143 force_sig(SIGKILL
, task
);
147 * Send or receive packet.
149 static int sock_xmit(struct nbd_device
*nbd
, int send
, void *buf
, int size
,
152 struct socket
*sock
= nbd
->sock
;
156 sigset_t blocked
, oldset
;
157 unsigned long pflags
= current
->flags
;
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"));
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
);
171 current
->flags
|= PF_MEMALLOC
;
173 sock
->sk
->sk_allocation
= GFP_NOIO
| __GFP_MEMALLOC
;
178 msg
.msg_control
= NULL
;
179 msg
.msg_controllen
= 0;
180 msg
.msg_flags
= msg_flags
| MSG_NOSIGNAL
;
183 struct timer_list ti
;
185 if (nbd
->xmit_timeout
) {
187 ti
.function
= nbd_xmit_timeout
;
188 ti
.data
= (unsigned long)current
;
189 ti
.expires
= jiffies
+ nbd
->xmit_timeout
;
192 result
= kernel_sendmsg(sock
, &msg
, &iov
, 1, size
);
193 if (nbd
->xmit_timeout
)
196 result
= kernel_recvmsg(sock
, &msg
, &iov
, 1, size
,
199 if (signal_pending(current
)) {
201 printk(KERN_WARNING
"nbd (pid %d: %s) got signal %d\n",
202 task_pid_nr(current
), current
->comm
,
203 dequeue_signal_lock(current
, ¤t
->blocked
, &info
));
205 sock_shutdown(nbd
, !send
);
211 result
= -EPIPE
; /* short read */
218 sigprocmask(SIG_SETMASK
, &oldset
, NULL
);
219 tsk_restore_flags(current
, pflags
, PF_MEMALLOC
);
224 static inline int sock_send_bvec(struct nbd_device
*nbd
, struct bio_vec
*bvec
,
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
);
235 /* always call with the tx_lock held */
236 static int nbd_send_req(struct nbd_device
*nbd
, struct request
*req
)
239 struct nbd_request request
;
240 unsigned long size
= blk_rq_bytes(req
);
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
));
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,
253 result
= sock_xmit(nbd
, 1, &request
, sizeof(request
),
254 (nbd_cmd(req
) == NBD_CMD_WRITE
) ? MSG_MORE
: 0);
256 dev_err(disk_to_dev(nbd
->disk
),
257 "Send control failed (result %d)\n", result
);
261 if (nbd_cmd(req
) == NBD_CMD_WRITE
) {
262 struct req_iterator iter
;
263 struct bio_vec
*bvec
;
265 * we are really probing at internals to determine
266 * whether to set MSG_MORE or not...
268 rq_for_each_segment(bvec
, req
, iter
) {
270 if (!rq_iter_last(req
, iter
))
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
);
276 dev_err(disk_to_dev(nbd
->disk
),
277 "Send data failed (result %d)\n",
289 static struct request
*nbd_find_request(struct nbd_device
*nbd
,
290 struct request
*xreq
)
292 struct request
*req
, *tmp
;
295 err
= wait_event_interruptible(nbd
->active_wq
, nbd
->active_req
!= xreq
);
299 spin_lock(&nbd
->queue_lock
);
300 list_for_each_entry_safe(req
, tmp
, &nbd
->queue_head
, queuelist
) {
303 list_del_init(&req
->queuelist
);
304 spin_unlock(&nbd
->queue_lock
);
307 spin_unlock(&nbd
->queue_lock
);
315 static inline int sock_recv_bvec(struct nbd_device
*nbd
, struct bio_vec
*bvec
)
318 void *kaddr
= kmap(bvec
->bv_page
);
319 result
= sock_xmit(nbd
, 0, kaddr
+ bvec
->bv_offset
, bvec
->bv_len
,
321 kunmap(bvec
->bv_page
);
325 /* NULL returned = something went wrong, inform userspace */
326 static struct request
*nbd_read_stat(struct nbd_device
*nbd
)
329 struct nbd_reply reply
;
333 result
= sock_xmit(nbd
, 0, &reply
, sizeof(reply
), MSG_WAITALL
);
335 dev_err(disk_to_dev(nbd
->disk
),
336 "Receive control failed (result %d)\n", result
);
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
));
347 req
= nbd_find_request(nbd
, *(struct request
**)reply
.handle
);
349 result
= PTR_ERR(req
);
350 if (result
!= -ENOENT
)
353 dev_err(disk_to_dev(nbd
->disk
), "Unexpected reply (%p)\n",
359 if (ntohl(reply
.error
)) {
360 dev_err(disk_to_dev(nbd
->disk
), "Other side returned error (%d)\n",
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
;
372 rq_for_each_segment(bvec
, req
, iter
) {
373 result
= sock_recv_bvec(nbd
, bvec
);
375 dev_err(disk_to_dev(nbd
->disk
), "Receive data failed (result %d)\n",
380 dprintk(DBG_RX
, "%s: request %p: got %d bytes data\n",
381 nbd
->disk
->disk_name
, req
, bvec
->bv_len
);
386 nbd
->harderror
= result
;
390 static ssize_t
pid_show(struct device
*dev
,
391 struct device_attribute
*attr
, char *buf
)
393 struct gendisk
*disk
= dev_to_disk(dev
);
395 return sprintf(buf
, "%ld\n",
396 (long) ((struct nbd_device
*)disk
->private_data
)->pid
);
399 static struct device_attribute pid_attr
= {
400 .attr
= { .name
= "pid", .mode
= S_IRUGO
},
404 static int nbd_do_it(struct nbd_device
*nbd
)
409 BUG_ON(nbd
->magic
!= NBD_MAGIC
);
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
);
415 dev_err(disk_to_dev(nbd
->disk
), "device_create_file failed!\n");
420 while ((req
= nbd_read_stat(nbd
)) != NULL
)
421 nbd_end_request(req
);
423 device_remove_file(disk_to_dev(nbd
->disk
), &pid_attr
);
428 static void nbd_clear_que(struct nbd_device
*nbd
)
432 BUG_ON(nbd
->magic
!= NBD_MAGIC
);
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.
439 * As a consequence, we don't need to take the spin lock while
440 * purging the list here.
443 BUG_ON(nbd
->active_req
);
445 while (!list_empty(&nbd
->queue_head
)) {
446 req
= list_entry(nbd
->queue_head
.next
, struct request
,
448 list_del_init(&req
->queuelist
);
450 nbd_end_request(req
);
455 static void nbd_handle_req(struct nbd_device
*nbd
, struct request
*req
)
457 if (req
->cmd_type
!= REQ_TYPE_FS
)
460 nbd_cmd(req
) = NBD_CMD_READ
;
461 if (rq_data_dir(req
) == WRITE
) {
462 nbd_cmd(req
) = NBD_CMD_WRITE
;
463 if (nbd
->flags
& NBD_READ_ONLY
) {
464 dev_err(disk_to_dev(nbd
->disk
),
465 "Write on read-only\n");
472 mutex_lock(&nbd
->tx_lock
);
473 if (unlikely(!nbd
->sock
)) {
474 mutex_unlock(&nbd
->tx_lock
);
475 dev_err(disk_to_dev(nbd
->disk
),
476 "Attempted send on closed socket\n");
480 nbd
->active_req
= req
;
482 if (nbd_send_req(nbd
, req
) != 0) {
483 dev_err(disk_to_dev(nbd
->disk
), "Request send failed\n");
485 nbd_end_request(req
);
487 spin_lock(&nbd
->queue_lock
);
488 list_add_tail(&req
->queuelist
, &nbd
->queue_head
);
489 spin_unlock(&nbd
->queue_lock
);
492 nbd
->active_req
= NULL
;
493 mutex_unlock(&nbd
->tx_lock
);
494 wake_up_all(&nbd
->active_wq
);
500 nbd_end_request(req
);
503 static int nbd_thread(void *data
)
505 struct nbd_device
*nbd
= data
;
508 set_user_nice(current
, -20);
509 while (!kthread_should_stop() || !list_empty(&nbd
->waiting_queue
)) {
510 /* wait for something to do */
511 wait_event_interruptible(nbd
->waiting_wq
,
512 kthread_should_stop() ||
513 !list_empty(&nbd
->waiting_queue
));
515 /* extract request */
516 if (list_empty(&nbd
->waiting_queue
))
519 spin_lock_irq(&nbd
->queue_lock
);
520 req
= list_entry(nbd
->waiting_queue
.next
, struct request
,
522 list_del_init(&req
->queuelist
);
523 spin_unlock_irq(&nbd
->queue_lock
);
526 nbd_handle_req(nbd
, req
);
532 * We always wait for result of write, for now. It would be nice to make it optional
534 * if ((rq_data_dir(req) == WRITE) && (nbd->flags & NBD_WRITE_NOCHK))
535 * { printk( "Warning: Ignoring result!\n"); nbd_end_request( req ); }
538 static void do_nbd_request(struct request_queue
*q
)
542 while ((req
= blk_fetch_request(q
)) != NULL
) {
543 struct nbd_device
*nbd
;
545 spin_unlock_irq(q
->queue_lock
);
547 dprintk(DBG_BLKDEV
, "%s: request %p: dequeued (flags=%x)\n",
548 req
->rq_disk
->disk_name
, req
, req
->cmd_type
);
550 nbd
= req
->rq_disk
->private_data
;
552 BUG_ON(nbd
->magic
!= NBD_MAGIC
);
554 if (unlikely(!nbd
->sock
)) {
555 dev_err(disk_to_dev(nbd
->disk
),
556 "Attempted send on closed socket\n");
558 nbd_end_request(req
);
559 spin_lock_irq(q
->queue_lock
);
563 spin_lock_irq(&nbd
->queue_lock
);
564 list_add_tail(&req
->queuelist
, &nbd
->waiting_queue
);
565 spin_unlock_irq(&nbd
->queue_lock
);
567 wake_up(&nbd
->waiting_wq
);
569 spin_lock_irq(q
->queue_lock
);
573 /* Must be called with tx_lock held */
575 static int __nbd_ioctl(struct block_device
*bdev
, struct nbd_device
*nbd
,
576 unsigned int cmd
, unsigned long arg
)
579 case NBD_DISCONNECT
: {
582 dev_info(disk_to_dev(nbd
->disk
), "NBD_DISCONNECT\n");
584 blk_rq_init(NULL
, &sreq
);
585 sreq
.cmd_type
= REQ_TYPE_SPECIAL
;
586 nbd_cmd(&sreq
) = NBD_CMD_DISC
;
589 nbd_send_req(nbd
, &sreq
);
593 case NBD_CLEAR_SOCK
: {
600 BUG_ON(!list_empty(&nbd
->queue_head
));
612 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
613 if (S_ISSOCK(inode
->i_mode
)) {
615 nbd
->sock
= SOCKET_I(inode
);
617 bdev
->bd_invalidated
= 1;
626 case NBD_SET_BLKSIZE
:
628 nbd
->bytesize
&= ~(nbd
->blksize
-1);
629 bdev
->bd_inode
->i_size
= nbd
->bytesize
;
630 set_blocksize(bdev
, nbd
->blksize
);
631 set_capacity(nbd
->disk
, nbd
->bytesize
>> 9);
635 nbd
->bytesize
= arg
& ~(nbd
->blksize
-1);
636 bdev
->bd_inode
->i_size
= nbd
->bytesize
;
637 set_blocksize(bdev
, nbd
->blksize
);
638 set_capacity(nbd
->disk
, nbd
->bytesize
>> 9);
641 case NBD_SET_TIMEOUT
:
642 nbd
->xmit_timeout
= arg
* HZ
;
645 case NBD_SET_SIZE_BLOCKS
:
646 nbd
->bytesize
= ((u64
) arg
) * nbd
->blksize
;
647 bdev
->bd_inode
->i_size
= nbd
->bytesize
;
648 set_blocksize(bdev
, nbd
->blksize
);
649 set_capacity(nbd
->disk
, nbd
->bytesize
>> 9);
653 struct task_struct
*thread
;
662 mutex_unlock(&nbd
->tx_lock
);
664 thread
= kthread_create(nbd_thread
, nbd
, nbd
->disk
->disk_name
);
665 if (IS_ERR(thread
)) {
666 mutex_lock(&nbd
->tx_lock
);
667 return PTR_ERR(thread
);
669 wake_up_process(thread
);
670 error
= nbd_do_it(nbd
);
671 kthread_stop(thread
);
673 mutex_lock(&nbd
->tx_lock
);
676 sock_shutdown(nbd
, 0);
680 dev_warn(disk_to_dev(nbd
->disk
), "queue cleared\n");
684 bdev
->bd_inode
->i_size
= 0;
685 set_capacity(nbd
->disk
, 0);
687 ioctl_by_bdev(bdev
, BLKRRPART
, 0);
688 return nbd
->harderror
;
693 * This is for compatibility only. The queue is always cleared
694 * by NBD_DO_IT or NBD_CLEAR_SOCK.
696 BUG_ON(!nbd
->sock
&& !list_empty(&nbd
->queue_head
));
699 case NBD_PRINT_DEBUG
:
700 dev_info(disk_to_dev(nbd
->disk
),
701 "next = %p, prev = %p, head = %p\n",
702 nbd
->queue_head
.next
, nbd
->queue_head
.prev
,
709 static int nbd_ioctl(struct block_device
*bdev
, fmode_t mode
,
710 unsigned int cmd
, unsigned long arg
)
712 struct nbd_device
*nbd
= bdev
->bd_disk
->private_data
;
715 if (!capable(CAP_SYS_ADMIN
))
718 BUG_ON(nbd
->magic
!= NBD_MAGIC
);
720 /* Anyone capable of this syscall can do *real bad* things */
721 dprintk(DBG_IOCTL
, "%s: nbd_ioctl cmd=%s(0x%x) arg=%lu\n",
722 nbd
->disk
->disk_name
, ioctl_cmd_to_ascii(cmd
), cmd
, arg
);
724 mutex_lock(&nbd
->tx_lock
);
725 error
= __nbd_ioctl(bdev
, nbd
, cmd
, arg
);
726 mutex_unlock(&nbd
->tx_lock
);
731 static const struct block_device_operations nbd_fops
=
733 .owner
= THIS_MODULE
,
738 * And here should be modules and kernel interface
739 * (Just smiley confuses emacs :-)
742 static int __init
nbd_init(void)
748 BUILD_BUG_ON(sizeof(struct nbd_request
) != 28);
751 printk(KERN_ERR
"nbd: max_part must be >= 0\n");
755 nbd_dev
= kcalloc(nbds_max
, sizeof(*nbd_dev
), GFP_KERNEL
);
761 part_shift
= fls(max_part
);
764 * Adjust max_part according to part_shift as it is exported
765 * to user space so that user can know the max number of
766 * partition kernel should be able to manage.
768 * Note that -1 is required because partition 0 is reserved
769 * for the whole disk.
771 max_part
= (1UL << part_shift
) - 1;
774 if ((1UL << part_shift
) > DISK_MAX_PARTS
)
777 if (nbds_max
> 1UL << (MINORBITS
- part_shift
))
780 for (i
= 0; i
< nbds_max
; i
++) {
781 struct gendisk
*disk
= alloc_disk(1 << part_shift
);
784 nbd_dev
[i
].disk
= disk
;
786 * The new linux 2.5 block layer implementation requires
787 * every gendisk to have its very own request_queue struct.
788 * These structs are big so we dynamically allocate them.
790 disk
->queue
= blk_init_queue(do_nbd_request
, &nbd_lock
);
796 * Tell the block layer that we are not a rotational device
798 queue_flag_set_unlocked(QUEUE_FLAG_NONROT
, disk
->queue
);
801 if (register_blkdev(NBD_MAJOR
, "nbd")) {
806 printk(KERN_INFO
"nbd: registered device at major %d\n", NBD_MAJOR
);
807 dprintk(DBG_INIT
, "nbd: debugflags=0x%x\n", debugflags
);
809 for (i
= 0; i
< nbds_max
; i
++) {
810 struct gendisk
*disk
= nbd_dev
[i
].disk
;
811 nbd_dev
[i
].file
= NULL
;
812 nbd_dev
[i
].magic
= NBD_MAGIC
;
813 nbd_dev
[i
].flags
= 0;
814 INIT_LIST_HEAD(&nbd_dev
[i
].waiting_queue
);
815 spin_lock_init(&nbd_dev
[i
].queue_lock
);
816 INIT_LIST_HEAD(&nbd_dev
[i
].queue_head
);
817 mutex_init(&nbd_dev
[i
].tx_lock
);
818 init_waitqueue_head(&nbd_dev
[i
].active_wq
);
819 init_waitqueue_head(&nbd_dev
[i
].waiting_wq
);
820 nbd_dev
[i
].blksize
= 1024;
821 nbd_dev
[i
].bytesize
= 0;
822 disk
->major
= NBD_MAJOR
;
823 disk
->first_minor
= i
<< part_shift
;
824 disk
->fops
= &nbd_fops
;
825 disk
->private_data
= &nbd_dev
[i
];
826 sprintf(disk
->disk_name
, "nbd%d", i
);
827 set_capacity(disk
, 0);
834 blk_cleanup_queue(nbd_dev
[i
].disk
->queue
);
835 put_disk(nbd_dev
[i
].disk
);
841 static void __exit
nbd_cleanup(void)
844 for (i
= 0; i
< nbds_max
; i
++) {
845 struct gendisk
*disk
= nbd_dev
[i
].disk
;
846 nbd_dev
[i
].magic
= 0;
849 blk_cleanup_queue(disk
->queue
);
853 unregister_blkdev(NBD_MAJOR
, "nbd");
855 printk(KERN_INFO
"nbd: unregistered device at major %d\n", NBD_MAJOR
);
858 module_init(nbd_init
);
859 module_exit(nbd_cleanup
);
861 MODULE_DESCRIPTION("Network Block Device");
862 MODULE_LICENSE("GPL");
864 module_param(nbds_max
, int, 0444);
865 MODULE_PARM_DESC(nbds_max
, "number of network block devices to initialize (default: 16)");
866 module_param(max_part
, int, 0444);
867 MODULE_PARM_DESC(max_part
, "number of partitions per device (default: 0)");
869 module_param(debugflags
, int, 0644);
870 MODULE_PARM_DESC(debugflags
, "flags for controlling debug output");