/* * bsg.c - block layer implementation of the sg v4 interface * * Copyright (C) 2004 Jens Axboe <axboe@suse.de> SUSE Labs * Copyright (C) 2004 Peter M. Jones <pjones@redhat.com> * *  This file is subject to the terms and conditions of the GNU General Public *  License version 2.  See the file "COPYING" in the main directory of this *  archive for more details. * */#include <linux/module.h>#include <linux/init.h>#include <linux/file.h>#include <linux/blkdev.h>#include <linux/poll.h>#include <linux/cdev.h>#include <linux/jiffies.h>#include <linux/percpu.h>#include <linux/uio.h>#include <linux/idr.h>#include <linux/bsg.h>#include <linux/slab.h> #include <scsi/scsi.h>#include <scsi/scsi_ioctl.h>#include <scsi/scsi_cmnd.h>#include <scsi/scsi_device.h>#include <scsi/scsi_driver.h>#include <scsi/sg.h> #define BSG_DESCRIPTION	"Block layer SCSI generic (bsg) driver"#define BSG_VERSION	"0.4" struct bsg_device {	struct request_queue *queue;	spinlock_t lock;	struct list_head busy_list;	struct list_head done_list;	struct hlist_node dev_list;	atomic_t ref_count;	int queued_cmds;	int done_cmds;	wait_queue_head_t wq_done;	wait_queue_head_t wq_free;	char name[20];	int max_queue;	unsigned long flags;}; enum {	BSG_F_BLOCK		= 1,}; #define BSG_DEFAULT_CMDS	64#define BSG_MAX_DEVS		32768 #undef BSG_DEBUG #ifdef BSG_DEBUG#define dprintk(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ##args)#else#define dprintk(fmt, args...)#endif static DEFINE_MUTEX(bsg_mutex);static DEFINE_IDR(bsg_minor_idr); #define BSG_LIST_ARRAY_SIZE	8static struct hlist_head bsg_device_list[BSG_LIST_ARRAY_SIZE]; static struct class *bsg_class;static int bsg_major; static struct kmem_cache *bsg_cmd_cachep; /* * our internal command type */struct bsg_command {	struct bsg_device *bd;	struct list_head list;	struct request *rq;	struct bio *bio;	struct bio *bidi_bio;	int err;	struct sg_io_v4 hdr;	char sense[SCSI_SENSE_BUFFERSIZE];}; static void bsg_free_command(struct bsg_command *bc){	struct bsg_device *bd = bc->bd;	unsigned long flags; 	kmem_cache_free(bsg_cmd_cachep, bc); 	spin_lock_irqsave(&bd->lock, flags);	bd->queued_cmds--;	spin_unlock_irqrestore(&bd->lock, flags); 	wake_up(&bd->wq_free);} static struct bsg_command *bsg_alloc_command(struct bsg_device *bd){	struct bsg_command *bc = ERR_PTR(-EINVAL); 	spin_lock_irq(&bd->lock); 	if (bd->queued_cmds >= bd->max_queue)		goto out; 	bd->queued_cmds++;	spin_unlock_irq(&bd->lock); 	bc = kmem_cache_zalloc(bsg_cmd_cachep, GFP_KERNEL);	if (unlikely(!bc)) {		spin_lock_irq(&bd->lock);		bd->queued_cmds--;		bc = ERR_PTR(-ENOMEM);		goto out;	} 	bc->bd = bd;	INIT_LIST_HEAD(&bc->list);	dprintk("%s: returning free cmd %p\n", bd->name, bc);	return bc;out:	spin_unlock_irq(&bd->lock);	return bc;} static inline struct hlist_head *bsg_dev_idx_hash(int index){	return &bsg_device_list[index & (BSG_LIST_ARRAY_SIZE - 1)];} static int bsg_io_schedule(struct bsg_device *bd){	DEFINE_WAIT(wait);	int ret = 0; 	spin_lock_irq(&bd->lock); 	BUG_ON(bd->done_cmds > bd->queued_cmds); 	/*	 * -ENOSPC or -ENODATA?  I'm going for -ENODATA, meaning "I have no	 * work to do", even though we return -ENOSPC after this same test	 * during bsg_write() -- there, it means our buffer can't have more	 * bsg_commands added to it, thus has no space left.	 */	if (bd->done_cmds == bd->queued_cmds) {		ret = -ENODATA;		goto unlock;	} 	if (!test_bit(BSG_F_BLOCK, &bd->flags)) {		ret = -EAGAIN;		goto unlock;	} 	prepare_to_wait(&bd->wq_done, &wait, TASK_UNINTERRUPTIBLE);	spin_unlock_irq(&bd->lock);	io_schedule();	finish_wait(&bd->wq_done, &wait); 	return ret;unlock:	spin_unlock_irq(&bd->lock);	return ret;} static int blk_fill_sgv4_hdr_rq(struct request_queue *q, struct request *rq,				struct sg_io_v4 *hdr, struct bsg_device *bd,				fmode_t has_write_perm){	if (hdr->request_len > BLK_MAX_CDB) {		rq->cmd = kzalloc(hdr->request_len, GFP_KERNEL);		if (!rq->cmd)			return -ENOMEM;	} 	if (copy_from_user(rq->cmd, (void __user *)(unsigned long)hdr->request,			   hdr->request_len))		return -EFAULT; 	if (hdr->subprotocol == BSG_SUB_PROTOCOL_SCSI_CMD) {		if (blk_verify_command(rq->cmd, has_write_perm))			return -EPERM;	} else if (!capable(CAP_SYS_RAWIO))		return -EPERM; 	/*	 * fill in request structure	 */	rq->cmd_len = hdr->request_len;	rq->cmd_type = REQ_TYPE_BLOCK_PC; 	rq->timeout = msecs_to_jiffies(hdr->timeout);	if (!rq->timeout)		rq->timeout = q->sg_timeout;	if (!rq->timeout)		rq->timeout = BLK_DEFAULT_SG_TIMEOUT;	if (rq->timeout < BLK_MIN_SG_TIMEOUT)		rq->timeout = BLK_MIN_SG_TIMEOUT; 	return 0;} /* * Check if sg_io_v4 from user is allowed and valid */static intbsg_validate_sgv4_hdr(struct request_queue *q, struct sg_io_v4 *hdr, int *rw){	int ret = 0; 	if (hdr->guard != 'Q')		return -EINVAL; 	switch (hdr->protocol) {	case BSG_PROTOCOL_SCSI:		switch (hdr->subprotocol) {		case BSG_SUB_PROTOCOL_SCSI_CMD:		case BSG_SUB_PROTOCOL_SCSI_TRANSPORT:			break;		default:			ret = -EINVAL;		}		break;	default:		ret = -EINVAL;	} 	*rw = hdr->dout_xfer_len ? WRITE : READ;	return ret;} /* * map sg_io_v4 to a request. */static struct request *bsg_map_hdr(struct bsg_device *bd, struct sg_io_v4 *hdr, fmode_t has_write_perm,	    u8 *sense){	struct request_queue *q = bd->queue;	struct request *rq, *next_rq = NULL;	int ret, rw;	unsigned int dxfer_len;	void __user *dxferp = NULL;	struct bsg_class_device *bcd = &q->bsg_dev; 	/* if the LLD has been removed then the bsg_unregister_queue will	 * eventually be called and the class_dev was freed, so we can no	 * longer use this request_queue. Return no such address.	 */	if (!bcd->class_dev)		return ERR_PTR(-ENXIO); 	dprintk("map hdr %llx/%u %llx/%u\n", (unsigned long long) hdr->dout_xferp,		hdr->dout_xfer_len, (unsigned long long) hdr->din_xferp,		hdr->din_xfer_len); 	ret = bsg_validate_sgv4_hdr(q, hdr, &rw);	if (ret)		return ERR_PTR(ret); 	/*	 * map scatter-gather elements separately and string them to request	 */	rq = blk_get_request(q, rw, GFP_KERNEL);	if (!rq)		return ERR_PTR(-ENOMEM);	ret = blk_fill_sgv4_hdr_rq(q, rq, hdr, bd, has_write_perm);	if (ret)		goto out; 	if (rw == WRITE && hdr->din_xfer_len) {		if (!test_bit(QUEUE_FLAG_BIDI, &q->queue_flags)) {			ret = -EOPNOTSUPP;			goto out;		} 		next_rq = blk_get_request(q, READ, GFP_KERNEL);		if (!next_rq) {			ret = -ENOMEM;			goto out;		}		rq->next_rq = next_rq;		next_rq->cmd_type = rq->cmd_type; 		dxferp = (void __user *)(unsigned long)hdr->din_xferp;		ret =  blk_rq_map_user(q, next_rq, NULL, dxferp,				       hdr->din_xfer_len, GFP_KERNEL);		if (ret)			goto out;	} 	if (hdr->dout_xfer_len) {		dxfer_len = hdr->dout_xfer_len;		dxferp = (void __user *)(unsigned long)hdr->dout_xferp;	} else if (hdr->din_xfer_len) {		dxfer_len = hdr->din_xfer_len;		dxferp = (void __user *)(unsigned long)hdr->din_xferp;	} else		dxfer_len = 0; 	if (dxfer_len) {		ret = blk_rq_map_user(q, rq, NULL, dxferp, dxfer_len,				      GFP_KERNEL);		if (ret)			goto out;	} 	rq->sense = sense;	rq->sense_len = 0; 	return rq;out:	if (rq->cmd != rq->__cmd)		kfree(rq->cmd);	blk_put_request(rq);	if (next_rq) {		blk_rq_unmap_user(next_rq->bio);		blk_put_request(next_rq);	}	return ERR_PTR(ret);} /* * async completion call-back from the block layer, when scsi/ide/whatever * calls end_that_request_last() on a request */static void bsg_rq_end_io(struct request *rq, int uptodate){	struct bsg_command *bc = rq->end_io_data;	struct bsg_device *bd = bc->bd;	unsigned long flags; 	dprintk("%s: finished rq %p bc %p, bio %p stat %d\n",		bd->name, rq, bc, bc->bio, uptodate); 	bc->hdr.duration = jiffies_to_msecs(jiffies - bc->hdr.duration); 	spin_lock_irqsave(&bd->lock, flags);	list_move_tail(&bc->list, &bd->done_list);	bd->done_cmds++;	spin_unlock_irqrestore(&bd->lock, flags); 	wake_up(&bd->wq_done);} /* * do final setup of a 'bc' and submit the matching 'rq' to the block * layer for io */static void bsg_add_command(struct bsg_device *bd, struct request_queue *q,			    struct bsg_command *bc, struct request *rq){	int at_head = (0 == (bc->hdr.flags & BSG_FLAG_Q_AT_TAIL)); 	/*	 * add bc command to busy queue and submit rq for io	 */	bc->rq = rq;	bc->bio = rq->bio;	if (rq->next_rq)		bc->bidi_bio = rq->next_rq->bio;	bc->hdr.duration = jiffies;	spin_lock_irq(&bd->lock);	list_add_tail(&bc->list, &bd->busy_list);	spin_unlock_irq(&bd->lock); 	dprintk("%s: queueing rq %p, bc %p\n", bd->name, rq, bc); 	rq->end_io_data = bc;	blk_execute_rq_nowait(q, NULL, rq, at_head, bsg_rq_end_io);} static struct bsg_command *bsg_next_done_cmd(struct bsg_device *bd){	struct bsg_command *bc = NULL; 	spin_lock_irq(&bd->lock);	if (bd->done_cmds) {		bc = list_first_entry(&bd->done_list, struct bsg_command, list);		list_del(&bc->list);		bd->done_cmds--;	}	spin_unlock_irq(&bd->lock); 	return bc;} /* * Get a finished command from the done list */static struct bsg_command *bsg_get_done_cmd(struct bsg_device *bd){	struct bsg_command *bc;	int ret; 	do {		bc = bsg_next_done_cmd(bd);		if (bc)			break; 		if (!test_bit(BSG_F_BLOCK, &bd->flags)) {			bc = ERR_PTR(-EAGAIN);			break;		} 		ret = wait_event_interruptible(bd->wq_done, bd->done_cmds);		if (ret) {			bc = ERR_PTR(-ERESTARTSYS);			break;		}	} while (1); 	dprintk("%s: returning done %p\n", bd->name, bc); 	return bc;} static int blk_complete_sgv4_hdr_rq(struct request *rq, struct sg_io_v4 *hdr,				    struct bio *bio, struct bio *bidi_bio){	int ret = 0; 	dprintk("rq %p bio %p 0x%x\n", rq, bio, rq->errors);	/*	 * fill in all the output members	 */	hdr->device_status = rq->errors & 0xff;	hdr->transport_status = host_byte(rq->errors);	hdr->driver_status = driver_byte(rq->errors);	hdr->info = 0;	if (hdr->device_status || hdr->transport_status || hdr->driver_status)		hdr->info |= SG_INFO_CHECK;	hdr->response_len = 0; 	if (rq->sense_len && hdr->response) {		int len = min_t(unsigned int, hdr->max_response_len,					rq->sense_len); 		ret = copy_to_user((void __user *)(unsigned long)hdr->response,				   rq->sense, len);		if (!ret)			hdr->response_len = len;		else			ret = -EFAULT;	} 	if (rq->next_rq) {		hdr->dout_resid = rq->resid_len;		hdr->din_resid = rq->next_rq->resid_len;		blk_rq_unmap_user(bidi_bio);		blk_put_request(rq->next_rq);	} else if (rq_data_dir(rq) == READ)		hdr->din_resid = rq->resid_len;	else		hdr->dout_resid = rq->resid_len; 	/*	 * If the request generated a negative error number, return it	 * (providing we aren't already returning an error); if it's	 * just a protocol response (i.e. non negative), that gets	 * processed above.	 */	if (!ret && rq->errors < 0)		ret = rq->errors; 	blk_rq_unmap_user(bio);	if (rq->cmd != rq->__cmd)		kfree(rq->cmd);	blk_put_request(rq); 	return ret;} static int bsg_complete_all_commands(struct bsg_device *bd){	struct bsg_command *bc;	int ret, tret; 	dprintk("%s: entered\n", bd->name); 	/*	 * wait for all commands to complete	 */	ret = 0;	do {		ret = bsg_io_schedule(bd);		/*		 * look for -ENODATA specifically -- we'll sometimes get		 * -ERESTARTSYS when we've taken a signal, but we can't		 * return until we're done freeing the queue, so ignore		 * it.  The signal will get handled when we're done freeing

Lines 1–500 of 1126. Load more