2 * bsg.c - block layer implementation of the sg v4 interface
4 * Copyright (C) 2004 Jens Axboe <axboe@suse.de> SUSE Labs
5 * Copyright (C) 2004 Peter M. Jones <pjones@redhat.com>
7 * This file is subject to the terms and conditions of the GNU General Public
8 * License version 2. See the file "COPYING" in the main directory of this
9 * archive for more details.
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/file.h>
15 #include <linux/blkdev.h>
16 #include <linux/poll.h>
17 #include <linux/cdev.h>
18 #include <linux/jiffies.h>
19 #include <linux/percpu.h>
20 #include <linux/uio.h>
21 #include <linux/idr.h>
22 #include <linux/bsg.h>
23 #include <linux/slab.h>
25 #include <scsi/scsi.h>
26 #include <scsi/scsi_ioctl.h>
27 #include <scsi/scsi_cmnd.h>
28 #include <scsi/scsi_device.h>
29 #include <scsi/scsi_driver.h>
32 #define BSG_DESCRIPTION "Block layer SCSI generic (bsg) driver"
33 #define BSG_VERSION "0.4"
36 struct request_queue
*queue
;
38 struct list_head busy_list
;
39 struct list_head done_list
;
40 struct hlist_node dev_list
;
44 wait_queue_head_t wq_done
;
45 wait_queue_head_t wq_free
;
55 #define BSG_DEFAULT_CMDS 64
56 #define BSG_MAX_DEVS 32768
61 #define dprintk(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ##args)
63 #define dprintk(fmt, args...)
66 static DEFINE_MUTEX(bsg_mutex
);
67 static DEFINE_IDR(bsg_minor_idr
);
69 #define BSG_LIST_ARRAY_SIZE 8
70 static struct hlist_head bsg_device_list
[BSG_LIST_ARRAY_SIZE
];
72 static struct class *bsg_class
;
75 static struct kmem_cache
*bsg_cmd_cachep
;
78 * our internal command type
81 struct bsg_device
*bd
;
82 struct list_head list
;
88 char sense
[SCSI_SENSE_BUFFERSIZE
];
91 static void bsg_free_command(struct bsg_command
*bc
)
93 struct bsg_device
*bd
= bc
->bd
;
96 kmem_cache_free(bsg_cmd_cachep
, bc
);
98 spin_lock_irqsave(&bd
->lock
, flags
);
100 spin_unlock_irqrestore(&bd
->lock
, flags
);
102 wake_up(&bd
->wq_free
);
105 static struct bsg_command
*bsg_alloc_command(struct bsg_device
*bd
)
107 struct bsg_command
*bc
= ERR_PTR(-EINVAL
);
109 spin_lock_irq(&bd
->lock
);
111 if (bd
->queued_cmds
>= bd
->max_queue
)
115 spin_unlock_irq(&bd
->lock
);
117 bc
= kmem_cache_zalloc(bsg_cmd_cachep
, GFP_KERNEL
);
119 spin_lock_irq(&bd
->lock
);
121 bc
= ERR_PTR(-ENOMEM
);
126 INIT_LIST_HEAD(&bc
->list
);
127 dprintk("%s: returning free cmd %p\n", bd
->name
, bc
);
130 spin_unlock_irq(&bd
->lock
);
134 static inline struct hlist_head
*bsg_dev_idx_hash(int index
)
136 return &bsg_device_list
[index
& (BSG_LIST_ARRAY_SIZE
- 1)];
139 static int blk_fill_sgv4_hdr_rq(struct request_queue
*q
, struct request
*rq
,
140 struct sg_io_v4
*hdr
, struct bsg_device
*bd
,
141 fmode_t has_write_perm
)
143 if (hdr
->request_len
> BLK_MAX_CDB
) {
144 rq
->cmd
= kzalloc(hdr
->request_len
, GFP_KERNEL
);
149 if (copy_from_user(rq
->cmd
, (void __user
*)(unsigned long)hdr
->request
,
153 if (hdr
->subprotocol
== BSG_SUB_PROTOCOL_SCSI_CMD
) {
154 if (blk_verify_command(rq
->cmd
, has_write_perm
))
156 } else if (!capable(CAP_SYS_RAWIO
))
160 * fill in request structure
162 rq
->cmd_len
= hdr
->request_len
;
164 rq
->timeout
= msecs_to_jiffies(hdr
->timeout
);
166 rq
->timeout
= q
->sg_timeout
;
168 rq
->timeout
= BLK_DEFAULT_SG_TIMEOUT
;
169 if (rq
->timeout
< BLK_MIN_SG_TIMEOUT
)
170 rq
->timeout
= BLK_MIN_SG_TIMEOUT
;
176 * Check if sg_io_v4 from user is allowed and valid
179 bsg_validate_sgv4_hdr(struct request_queue
*q
, struct sg_io_v4
*hdr
, int *rw
)
183 if (hdr
->guard
!= 'Q')
186 switch (hdr
->protocol
) {
187 case BSG_PROTOCOL_SCSI
:
188 switch (hdr
->subprotocol
) {
189 case BSG_SUB_PROTOCOL_SCSI_CMD
:
190 case BSG_SUB_PROTOCOL_SCSI_TRANSPORT
:
200 *rw
= hdr
->dout_xfer_len
? WRITE
: READ
;
205 * map sg_io_v4 to a request.
207 static struct request
*
208 bsg_map_hdr(struct bsg_device
*bd
, struct sg_io_v4
*hdr
, fmode_t has_write_perm
,
211 struct request_queue
*q
= bd
->queue
;
212 struct request
*rq
, *next_rq
= NULL
;
214 unsigned int dxfer_len
;
215 void __user
*dxferp
= NULL
;
216 struct bsg_class_device
*bcd
= &q
->bsg_dev
;
218 /* if the LLD has been removed then the bsg_unregister_queue will
219 * eventually be called and the class_dev was freed, so we can no
220 * longer use this request_queue. Return no such address.
223 return ERR_PTR(-ENXIO
);
225 dprintk("map hdr %llx/%u %llx/%u\n", (unsigned long long) hdr
->dout_xferp
,
226 hdr
->dout_xfer_len
, (unsigned long long) hdr
->din_xferp
,
229 ret
= bsg_validate_sgv4_hdr(q
, hdr
, &rw
);
234 * map scatter-gather elements separately and string them to request
236 rq
= blk_get_request(q
, rw
, GFP_KERNEL
);
239 blk_rq_set_block_pc(rq
);
241 ret
= blk_fill_sgv4_hdr_rq(q
, rq
, hdr
, bd
, has_write_perm
);
245 if (rw
== WRITE
&& hdr
->din_xfer_len
) {
246 if (!test_bit(QUEUE_FLAG_BIDI
, &q
->queue_flags
)) {
251 next_rq
= blk_get_request(q
, READ
, GFP_KERNEL
);
252 if (IS_ERR(next_rq
)) {
253 ret
= PTR_ERR(next_rq
);
257 rq
->next_rq
= next_rq
;
258 next_rq
->cmd_type
= rq
->cmd_type
;
260 dxferp
= (void __user
*)(unsigned long)hdr
->din_xferp
;
261 ret
= blk_rq_map_user(q
, next_rq
, NULL
, dxferp
,
262 hdr
->din_xfer_len
, GFP_KERNEL
);
267 if (hdr
->dout_xfer_len
) {
268 dxfer_len
= hdr
->dout_xfer_len
;
269 dxferp
= (void __user
*)(unsigned long)hdr
->dout_xferp
;
270 } else if (hdr
->din_xfer_len
) {
271 dxfer_len
= hdr
->din_xfer_len
;
272 dxferp
= (void __user
*)(unsigned long)hdr
->din_xferp
;
277 ret
= blk_rq_map_user(q
, rq
, NULL
, dxferp
, dxfer_len
,
288 if (rq
->cmd
!= rq
->__cmd
)
292 blk_rq_unmap_user(next_rq
->bio
);
293 blk_put_request(next_rq
);
299 * async completion call-back from the block layer, when scsi/ide/whatever
300 * calls end_that_request_last() on a request
302 static void bsg_rq_end_io(struct request
*rq
, int uptodate
)
304 struct bsg_command
*bc
= rq
->end_io_data
;
305 struct bsg_device
*bd
= bc
->bd
;
308 dprintk("%s: finished rq %p bc %p, bio %p stat %d\n",
309 bd
->name
, rq
, bc
, bc
->bio
, uptodate
);
311 bc
->hdr
.duration
= jiffies_to_msecs(jiffies
- bc
->hdr
.duration
);
313 spin_lock_irqsave(&bd
->lock
, flags
);
314 list_move_tail(&bc
->list
, &bd
->done_list
);
316 spin_unlock_irqrestore(&bd
->lock
, flags
);
318 wake_up(&bd
->wq_done
);
322 * do final setup of a 'bc' and submit the matching 'rq' to the block
325 static void bsg_add_command(struct bsg_device
*bd
, struct request_queue
*q
,
326 struct bsg_command
*bc
, struct request
*rq
)
328 int at_head
= (0 == (bc
->hdr
.flags
& BSG_FLAG_Q_AT_TAIL
));
331 * add bc command to busy queue and submit rq for io
336 bc
->bidi_bio
= rq
->next_rq
->bio
;
337 bc
->hdr
.duration
= jiffies
;
338 spin_lock_irq(&bd
->lock
);
339 list_add_tail(&bc
->list
, &bd
->busy_list
);
340 spin_unlock_irq(&bd
->lock
);
342 dprintk("%s: queueing rq %p, bc %p\n", bd
->name
, rq
, bc
);
344 rq
->end_io_data
= bc
;
345 blk_execute_rq_nowait(q
, NULL
, rq
, at_head
, bsg_rq_end_io
);
348 static struct bsg_command
*bsg_next_done_cmd(struct bsg_device
*bd
)
350 struct bsg_command
*bc
= NULL
;
352 spin_lock_irq(&bd
->lock
);
354 bc
= list_first_entry(&bd
->done_list
, struct bsg_command
, list
);
358 spin_unlock_irq(&bd
->lock
);
364 * Get a finished command from the done list
366 static struct bsg_command
*bsg_get_done_cmd(struct bsg_device
*bd
)
368 struct bsg_command
*bc
;
372 bc
= bsg_next_done_cmd(bd
);
376 if (!test_bit(BSG_F_BLOCK
, &bd
->flags
)) {
377 bc
= ERR_PTR(-EAGAIN
);
381 ret
= wait_event_interruptible(bd
->wq_done
, bd
->done_cmds
);
383 bc
= ERR_PTR(-ERESTARTSYS
);
388 dprintk("%s: returning done %p\n", bd
->name
, bc
);
393 static int blk_complete_sgv4_hdr_rq(struct request
*rq
, struct sg_io_v4
*hdr
,
394 struct bio
*bio
, struct bio
*bidi_bio
)
398 dprintk("rq %p bio %p 0x%x\n", rq
, bio
, rq
->errors
);
400 * fill in all the output members
402 hdr
->device_status
= rq
->errors
& 0xff;
403 hdr
->transport_status
= host_byte(rq
->errors
);
404 hdr
->driver_status
= driver_byte(rq
->errors
);
406 if (hdr
->device_status
|| hdr
->transport_status
|| hdr
->driver_status
)
407 hdr
->info
|= SG_INFO_CHECK
;
408 hdr
->response_len
= 0;
410 if (rq
->sense_len
&& hdr
->response
) {
411 int len
= min_t(unsigned int, hdr
->max_response_len
,
414 ret
= copy_to_user((void __user
*)(unsigned long)hdr
->response
,
417 hdr
->response_len
= len
;
423 hdr
->dout_resid
= rq
->resid_len
;
424 hdr
->din_resid
= rq
->next_rq
->resid_len
;
425 blk_rq_unmap_user(bidi_bio
);
426 blk_put_request(rq
->next_rq
);
427 } else if (rq_data_dir(rq
) == READ
)
428 hdr
->din_resid
= rq
->resid_len
;
430 hdr
->dout_resid
= rq
->resid_len
;
433 * If the request generated a negative error number, return it
434 * (providing we aren't already returning an error); if it's
435 * just a protocol response (i.e. non negative), that gets
438 if (!ret
&& rq
->errors
< 0)
441 blk_rq_unmap_user(bio
);
442 if (rq
->cmd
!= rq
->__cmd
)
449 static bool bsg_complete(struct bsg_device
*bd
)
455 spin_lock_irq(&bd
->lock
);
457 BUG_ON(bd
->done_cmds
> bd
->queued_cmds
);
460 * All commands consumed.
462 if (bd
->done_cmds
== bd
->queued_cmds
)
465 spin
= !test_bit(BSG_F_BLOCK
, &bd
->flags
);
467 spin_unlock_irq(&bd
->lock
);
468 } while (!ret
&& spin
);
473 static int bsg_complete_all_commands(struct bsg_device
*bd
)
475 struct bsg_command
*bc
;
478 dprintk("%s: entered\n", bd
->name
);
481 * wait for all commands to complete
483 io_wait_event(bd
->wq_done
, bsg_complete(bd
));
486 * discard done commands
490 spin_lock_irq(&bd
->lock
);
491 if (!bd
->queued_cmds
) {
492 spin_unlock_irq(&bd
->lock
);
495 spin_unlock_irq(&bd
->lock
);
497 bc
= bsg_get_done_cmd(bd
);
501 tret
= blk_complete_sgv4_hdr_rq(bc
->rq
, &bc
->hdr
, bc
->bio
,
506 bsg_free_command(bc
);
513 __bsg_read(char __user
*buf
, size_t count
, struct bsg_device
*bd
,
514 const struct iovec
*iov
, ssize_t
*bytes_read
)
516 struct bsg_command
*bc
;
517 int nr_commands
, ret
;
519 if (count
% sizeof(struct sg_io_v4
))
523 nr_commands
= count
/ sizeof(struct sg_io_v4
);
524 while (nr_commands
) {
525 bc
= bsg_get_done_cmd(bd
);
532 * this is the only case where we need to copy data back
533 * after completing the request. so do that here,
534 * bsg_complete_work() cannot do that for us
536 ret
= blk_complete_sgv4_hdr_rq(bc
->rq
, &bc
->hdr
, bc
->bio
,
539 if (copy_to_user(buf
, &bc
->hdr
, sizeof(bc
->hdr
)))
542 bsg_free_command(bc
);
547 buf
+= sizeof(struct sg_io_v4
);
548 *bytes_read
+= sizeof(struct sg_io_v4
);
555 static inline void bsg_set_block(struct bsg_device
*bd
, struct file
*file
)
557 if (file
->f_flags
& O_NONBLOCK
)
558 clear_bit(BSG_F_BLOCK
, &bd
->flags
);
560 set_bit(BSG_F_BLOCK
, &bd
->flags
);
564 * Check if the error is a "real" error that we should return.
566 static inline int err_block_err(int ret
)
568 if (ret
&& ret
!= -ENOSPC
&& ret
!= -ENODATA
&& ret
!= -EAGAIN
)
575 bsg_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
577 struct bsg_device
*bd
= file
->private_data
;
581 dprintk("%s: read %Zd bytes\n", bd
->name
, count
);
583 bsg_set_block(bd
, file
);
586 ret
= __bsg_read(buf
, count
, bd
, NULL
, &bytes_read
);
589 if (!bytes_read
|| err_block_err(ret
))
595 static int __bsg_write(struct bsg_device
*bd
, const char __user
*buf
,
596 size_t count
, ssize_t
*bytes_written
,
597 fmode_t has_write_perm
)
599 struct bsg_command
*bc
;
601 int ret
, nr_commands
;
603 if (count
% sizeof(struct sg_io_v4
))
606 nr_commands
= count
/ sizeof(struct sg_io_v4
);
610 while (nr_commands
) {
611 struct request_queue
*q
= bd
->queue
;
613 bc
= bsg_alloc_command(bd
);
620 if (copy_from_user(&bc
->hdr
, buf
, sizeof(bc
->hdr
))) {
626 * get a request, fill in the blanks, and add to request queue
628 rq
= bsg_map_hdr(bd
, &bc
->hdr
, has_write_perm
, bc
->sense
);
635 bsg_add_command(bd
, q
, bc
, rq
);
639 buf
+= sizeof(struct sg_io_v4
);
640 *bytes_written
+= sizeof(struct sg_io_v4
);
644 bsg_free_command(bc
);
650 bsg_write(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*ppos
)
652 struct bsg_device
*bd
= file
->private_data
;
653 ssize_t bytes_written
;
656 dprintk("%s: write %Zd bytes\n", bd
->name
, count
);
658 bsg_set_block(bd
, file
);
661 ret
= __bsg_write(bd
, buf
, count
, &bytes_written
,
662 file
->f_mode
& FMODE_WRITE
);
664 *ppos
= bytes_written
;
667 * return bytes written on non-fatal errors
669 if (!bytes_written
|| err_block_err(ret
))
672 dprintk("%s: returning %Zd\n", bd
->name
, bytes_written
);
673 return bytes_written
;
676 static struct bsg_device
*bsg_alloc_device(void)
678 struct bsg_device
*bd
;
680 bd
= kzalloc(sizeof(struct bsg_device
), GFP_KERNEL
);
684 spin_lock_init(&bd
->lock
);
686 bd
->max_queue
= BSG_DEFAULT_CMDS
;
688 INIT_LIST_HEAD(&bd
->busy_list
);
689 INIT_LIST_HEAD(&bd
->done_list
);
690 INIT_HLIST_NODE(&bd
->dev_list
);
692 init_waitqueue_head(&bd
->wq_free
);
693 init_waitqueue_head(&bd
->wq_done
);
697 static void bsg_kref_release_function(struct kref
*kref
)
699 struct bsg_class_device
*bcd
=
700 container_of(kref
, struct bsg_class_device
, ref
);
701 struct device
*parent
= bcd
->parent
;
704 bcd
->release(bcd
->parent
);
709 static int bsg_put_device(struct bsg_device
*bd
)
711 int ret
= 0, do_free
;
712 struct request_queue
*q
= bd
->queue
;
714 mutex_lock(&bsg_mutex
);
716 do_free
= atomic_dec_and_test(&bd
->ref_count
);
718 mutex_unlock(&bsg_mutex
);
722 hlist_del(&bd
->dev_list
);
723 mutex_unlock(&bsg_mutex
);
725 dprintk("%s: tearing down\n", bd
->name
);
728 * close can always block
730 set_bit(BSG_F_BLOCK
, &bd
->flags
);
733 * correct error detection baddies here again. it's the responsibility
734 * of the app to properly reap commands before close() if it wants
735 * fool-proof error detection
737 ret
= bsg_complete_all_commands(bd
);
741 kref_put(&q
->bsg_dev
.ref
, bsg_kref_release_function
);
747 static struct bsg_device
*bsg_add_device(struct inode
*inode
,
748 struct request_queue
*rq
,
751 struct bsg_device
*bd
;
753 unsigned char buf
[32];
755 if (!blk_get_queue(rq
))
756 return ERR_PTR(-ENXIO
);
758 bd
= bsg_alloc_device();
761 return ERR_PTR(-ENOMEM
);
766 bsg_set_block(bd
, file
);
768 atomic_set(&bd
->ref_count
, 1);
769 mutex_lock(&bsg_mutex
);
770 hlist_add_head(&bd
->dev_list
, bsg_dev_idx_hash(iminor(inode
)));
772 strncpy(bd
->name
, dev_name(rq
->bsg_dev
.class_dev
), sizeof(bd
->name
) - 1);
773 dprintk("bound to <%s>, max queue %d\n",
774 format_dev_t(buf
, inode
->i_rdev
), bd
->max_queue
);
776 mutex_unlock(&bsg_mutex
);
780 static struct bsg_device
*__bsg_get_device(int minor
, struct request_queue
*q
)
782 struct bsg_device
*bd
;
784 mutex_lock(&bsg_mutex
);
786 hlist_for_each_entry(bd
, bsg_dev_idx_hash(minor
), dev_list
) {
787 if (bd
->queue
== q
) {
788 atomic_inc(&bd
->ref_count
);
794 mutex_unlock(&bsg_mutex
);
798 static struct bsg_device
*bsg_get_device(struct inode
*inode
, struct file
*file
)
800 struct bsg_device
*bd
;
801 struct bsg_class_device
*bcd
;
804 * find the class device
806 mutex_lock(&bsg_mutex
);
807 bcd
= idr_find(&bsg_minor_idr
, iminor(inode
));
810 mutex_unlock(&bsg_mutex
);
813 return ERR_PTR(-ENODEV
);
815 bd
= __bsg_get_device(iminor(inode
), bcd
->queue
);
819 bd
= bsg_add_device(inode
, bcd
->queue
, file
);
821 kref_put(&bcd
->ref
, bsg_kref_release_function
);
826 static int bsg_open(struct inode
*inode
, struct file
*file
)
828 struct bsg_device
*bd
;
830 bd
= bsg_get_device(inode
, file
);
835 file
->private_data
= bd
;
839 static int bsg_release(struct inode
*inode
, struct file
*file
)
841 struct bsg_device
*bd
= file
->private_data
;
843 file
->private_data
= NULL
;
844 return bsg_put_device(bd
);
847 static unsigned int bsg_poll(struct file
*file
, poll_table
*wait
)
849 struct bsg_device
*bd
= file
->private_data
;
850 unsigned int mask
= 0;
852 poll_wait(file
, &bd
->wq_done
, wait
);
853 poll_wait(file
, &bd
->wq_free
, wait
);
855 spin_lock_irq(&bd
->lock
);
856 if (!list_empty(&bd
->done_list
))
857 mask
|= POLLIN
| POLLRDNORM
;
858 if (bd
->queued_cmds
< bd
->max_queue
)
860 spin_unlock_irq(&bd
->lock
);
865 static long bsg_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
867 struct bsg_device
*bd
= file
->private_data
;
868 int __user
*uarg
= (int __user
*) arg
;
875 case SG_GET_COMMAND_Q
:
876 return put_user(bd
->max_queue
, uarg
);
877 case SG_SET_COMMAND_Q
: {
880 if (get_user(queue
, uarg
))
885 spin_lock_irq(&bd
->lock
);
886 bd
->max_queue
= queue
;
887 spin_unlock_irq(&bd
->lock
);
894 case SG_GET_VERSION_NUM
:
895 case SCSI_IOCTL_GET_IDLUN
:
896 case SCSI_IOCTL_GET_BUS_NUMBER
:
899 case SG_GET_RESERVED_SIZE
:
900 case SG_SET_RESERVED_SIZE
:
901 case SG_EMULATED_HOST
:
902 case SCSI_IOCTL_SEND_COMMAND
: {
903 void __user
*uarg
= (void __user
*) arg
;
904 return scsi_cmd_ioctl(bd
->queue
, NULL
, file
->f_mode
, cmd
, uarg
);
908 struct bio
*bio
, *bidi_bio
= NULL
;
911 u8 sense
[SCSI_SENSE_BUFFERSIZE
];
913 if (copy_from_user(&hdr
, uarg
, sizeof(hdr
)))
916 rq
= bsg_map_hdr(bd
, &hdr
, file
->f_mode
& FMODE_WRITE
, sense
);
922 bidi_bio
= rq
->next_rq
->bio
;
924 at_head
= (0 == (hdr
.flags
& BSG_FLAG_Q_AT_TAIL
));
925 blk_execute_rq(bd
->queue
, NULL
, rq
, at_head
);
926 ret
= blk_complete_sgv4_hdr_rq(rq
, &hdr
, bio
, bidi_bio
);
928 if (copy_to_user(uarg
, &hdr
, sizeof(hdr
)))
934 * block device ioctls
938 return ioctl_by_bdev(bd
->bdev
, cmd
, arg
);
945 static const struct file_operations bsg_fops
= {
950 .release
= bsg_release
,
951 .unlocked_ioctl
= bsg_ioctl
,
952 .owner
= THIS_MODULE
,
953 .llseek
= default_llseek
,
956 void bsg_unregister_queue(struct request_queue
*q
)
958 struct bsg_class_device
*bcd
= &q
->bsg_dev
;
963 mutex_lock(&bsg_mutex
);
964 idr_remove(&bsg_minor_idr
, bcd
->minor
);
966 sysfs_remove_link(&q
->kobj
, "bsg");
967 device_unregister(bcd
->class_dev
);
968 bcd
->class_dev
= NULL
;
969 kref_put(&bcd
->ref
, bsg_kref_release_function
);
970 mutex_unlock(&bsg_mutex
);
972 EXPORT_SYMBOL_GPL(bsg_unregister_queue
);
974 int bsg_register_queue(struct request_queue
*q
, struct device
*parent
,
975 const char *name
, void (*release
)(struct device
*))
977 struct bsg_class_device
*bcd
;
980 struct device
*class_dev
= NULL
;
986 devname
= dev_name(parent
);
989 * we need a proper transport to send commands, not a stacked device
991 if (!queue_is_rq_based(q
))
995 memset(bcd
, 0, sizeof(*bcd
));
997 mutex_lock(&bsg_mutex
);
999 ret
= idr_alloc(&bsg_minor_idr
, bcd
, 0, BSG_MAX_DEVS
, GFP_KERNEL
);
1001 if (ret
== -ENOSPC
) {
1002 printk(KERN_ERR
"bsg: too many bsg devices\n");
1010 bcd
->parent
= get_device(parent
);
1011 bcd
->release
= release
;
1012 kref_init(&bcd
->ref
);
1013 dev
= MKDEV(bsg_major
, bcd
->minor
);
1014 class_dev
= device_create(bsg_class
, parent
, dev
, NULL
, "%s", devname
);
1015 if (IS_ERR(class_dev
)) {
1016 ret
= PTR_ERR(class_dev
);
1019 bcd
->class_dev
= class_dev
;
1022 ret
= sysfs_create_link(&q
->kobj
, &bcd
->class_dev
->kobj
, "bsg");
1024 goto unregister_class_dev
;
1027 mutex_unlock(&bsg_mutex
);
1030 unregister_class_dev
:
1031 device_unregister(class_dev
);
1034 idr_remove(&bsg_minor_idr
, bcd
->minor
);
1036 mutex_unlock(&bsg_mutex
);
1039 EXPORT_SYMBOL_GPL(bsg_register_queue
);
1041 static struct cdev bsg_cdev
;
1043 static char *bsg_devnode(struct device
*dev
, umode_t
*mode
)
1045 return kasprintf(GFP_KERNEL
, "bsg/%s", dev_name(dev
));
1048 static int __init
bsg_init(void)
1053 bsg_cmd_cachep
= kmem_cache_create("bsg_cmd",
1054 sizeof(struct bsg_command
), 0, 0, NULL
);
1055 if (!bsg_cmd_cachep
) {
1056 printk(KERN_ERR
"bsg: failed creating slab cache\n");
1060 for (i
= 0; i
< BSG_LIST_ARRAY_SIZE
; i
++)
1061 INIT_HLIST_HEAD(&bsg_device_list
[i
]);
1063 bsg_class
= class_create(THIS_MODULE
, "bsg");
1064 if (IS_ERR(bsg_class
)) {
1065 ret
= PTR_ERR(bsg_class
);
1066 goto destroy_kmemcache
;
1068 bsg_class
->devnode
= bsg_devnode
;
1070 ret
= alloc_chrdev_region(&devid
, 0, BSG_MAX_DEVS
, "bsg");
1072 goto destroy_bsg_class
;
1074 bsg_major
= MAJOR(devid
);
1076 cdev_init(&bsg_cdev
, &bsg_fops
);
1077 ret
= cdev_add(&bsg_cdev
, MKDEV(bsg_major
, 0), BSG_MAX_DEVS
);
1079 goto unregister_chrdev
;
1081 printk(KERN_INFO BSG_DESCRIPTION
" version " BSG_VERSION
1082 " loaded (major %d)\n", bsg_major
);
1085 unregister_chrdev_region(MKDEV(bsg_major
, 0), BSG_MAX_DEVS
);
1087 class_destroy(bsg_class
);
1089 kmem_cache_destroy(bsg_cmd_cachep
);
1093 MODULE_AUTHOR("Jens Axboe");
1094 MODULE_DESCRIPTION(BSG_DESCRIPTION
);
1095 MODULE_LICENSE("GPL");
1097 device_initcall(bsg_init
);