Merge branch 'for-linus' of git://git.kernel.dk/linux-2.6-block (0559bc8e) · Commits · e / devices / android_kernel_sony_msm8994

block/blk-core.c

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -582,6 +582,8 @@ blk_init_queue_node(request_fn_proc rfn, spinlock_t lock, int node_id)

	q->sg_reserved_size = INT_MAX;		q->sg_reserved_size = INT_MAX;

			blk_set_cmd_filter_defaults(&q->cmd_filter);

	/*		/*
	* all done		* all done
	*/		*/

block/blk-tag.c

+2 −4

Original line number	Original line	Diff line number	Diff line
	@@ -38,7 +38,8 @@ static int __blk_free_tags(struct blk_queue_tag *bqt)

	retval = atomic_dec_and_test(&bqt->refcnt);		retval = atomic_dec_and_test(&bqt->refcnt);
	if (retval) {		if (retval) {
	BUG_ON(bqt->busy);		BUG_ON(find_first_bit(bqt->tag_map, bqt->max_depth) <
			bqt->max_depth);

	kfree(bqt->tag_index);		kfree(bqt->tag_index);
	bqt->tag_index = NULL;		bqt->tag_index = NULL;
	@@ -147,7 +148,6 @@ static struct blk_queue_tag __blk_queue_init_tags(struct request_queue q,
	if (init_tag_map(q, tags, depth))		if (init_tag_map(q, tags, depth))
	goto fail;		goto fail;

	tags->busy = 0;
	atomic_set(&tags->refcnt, 1);		atomic_set(&tags->refcnt, 1);
	return tags;		return tags;
	fail:		fail:
	@@ -313,7 +313,6 @@ void blk_queue_end_tag(struct request_queue q, struct request rq)
	* unlock memory barrier semantics.		* unlock memory barrier semantics.
	*/		*/
	clear_bit_unlock(tag, bqt->tag_map);		clear_bit_unlock(tag, bqt->tag_map);
	bqt->busy--;
	}		}
	EXPORT_SYMBOL(blk_queue_end_tag);		EXPORT_SYMBOL(blk_queue_end_tag);

	@@ -368,7 +367,6 @@ int blk_queue_start_tag(struct request_queue q, struct request rq)
	bqt->tag_index[tag] = rq;		bqt->tag_index[tag] = rq;
	blkdev_dequeue_request(rq);		blkdev_dequeue_request(rq);
	list_add(&rq->queuelist, &q->tag_busy_list);		list_add(&rq->queuelist, &q->tag_busy_list);
	bqt->busy++;
	return 0;		return 0;
	}		}
	EXPORT_SYMBOL(blk_queue_start_tag);		EXPORT_SYMBOL(blk_queue_start_tag);

block/bsg.c

+11 −33

Original line number	Original line	Diff line number	Diff line
	@@ -45,8 +45,6 @@ struct bsg_device {
	char name[BUS_ID_SIZE];		char name[BUS_ID_SIZE];
	int max_queue;		int max_queue;
	unsigned long flags;		unsigned long flags;
	struct blk_scsi_cmd_filter *cmd_filter;
	mode_t *f_mode;
	};		};

	enum {		enum {
	@@ -174,7 +172,8 @@ unlock:
	}		}

	static int blk_fill_sgv4_hdr_rq(struct request_queue q, struct request rq,		static int blk_fill_sgv4_hdr_rq(struct request_queue q, struct request rq,
	struct sg_io_v4 hdr, struct bsg_device bd)		struct sg_io_v4 hdr, struct bsg_device bd,
			int has_write_perm)
	{		{
	if (hdr->request_len > BLK_MAX_CDB) {		if (hdr->request_len > BLK_MAX_CDB) {
	rq->cmd = kzalloc(hdr->request_len, GFP_KERNEL);		rq->cmd = kzalloc(hdr->request_len, GFP_KERNEL);
	@@ -187,8 +186,7 @@ static int blk_fill_sgv4_hdr_rq(struct request_queue q, struct request rq,
	return -EFAULT;		return -EFAULT;

	if (hdr->subprotocol == BSG_SUB_PROTOCOL_SCSI_CMD) {		if (hdr->subprotocol == BSG_SUB_PROTOCOL_SCSI_CMD) {
	if (blk_cmd_filter_verify_command(bd->cmd_filter, rq->cmd,		if (blk_verify_command(&q->cmd_filter, rq->cmd, has_write_perm))
	bd->f_mode))
	return -EPERM;		return -EPERM;
	} else if (!capable(CAP_SYS_RAWIO))		} else if (!capable(CAP_SYS_RAWIO))
	return -EPERM;		return -EPERM;
	@@ -244,7 +242,7 @@ bsg_validate_sgv4_hdr(struct request_queue q, struct sg_io_v4 hdr, int *rw)
	* map sg_io_v4 to a request.		* map sg_io_v4 to a request.
	*/		*/
	static struct request *		static struct request *
	bsg_map_hdr(struct bsg_device bd, struct sg_io_v4 hdr)		bsg_map_hdr(struct bsg_device bd, struct sg_io_v4 hdr, int has_write_perm)
	{		{
	struct request_queue *q = bd->queue;		struct request_queue *q = bd->queue;
	struct request rq, next_rq = NULL;		struct request rq, next_rq = NULL;
	@@ -266,7 +264,7 @@ bsg_map_hdr(struct bsg_device bd, struct sg_io_v4 hdr)
	rq = blk_get_request(q, rw, GFP_KERNEL);		rq = blk_get_request(q, rw, GFP_KERNEL);
	if (!rq)		if (!rq)
	return ERR_PTR(-ENOMEM);		return ERR_PTR(-ENOMEM);
	ret = blk_fill_sgv4_hdr_rq(q, rq, hdr, bd);		ret = blk_fill_sgv4_hdr_rq(q, rq, hdr, bd, has_write_perm);
	if (ret)		if (ret)
	goto out;		goto out;

	@@ -568,25 +566,6 @@ static inline void bsg_set_block(struct bsg_device bd, struct file file)
	set_bit(BSG_F_BLOCK, &bd->flags);		set_bit(BSG_F_BLOCK, &bd->flags);
	}		}

	static void bsg_set_cmd_filter(struct bsg_device *bd,
	struct file *file)
	{
	struct inode *inode;
	struct gendisk *disk;

	if (!file)
	return;

	inode = file->f_dentry->d_inode;
	if (!inode)
	return;

	disk = inode->i_bdev->bd_disk;

	bd->cmd_filter = &disk->cmd_filter;
	bd->f_mode = &file->f_mode;
	}

	/*		/*
	* Check if the error is a "real" error that we should return.		* Check if the error is a "real" error that we should return.
	*/		*/
	@@ -608,7 +587,6 @@ bsg_read(struct file file, char __user buf, size_t count, loff_t *ppos)
	dprintk("%s: read %Zd bytes\n", bd->name, count);		dprintk("%s: read %Zd bytes\n", bd->name, count);

	bsg_set_block(bd, file);		bsg_set_block(bd, file);
	bsg_set_cmd_filter(bd, file);

	bytes_read = 0;		bytes_read = 0;
	ret = __bsg_read(buf, count, bd, NULL, &bytes_read);		ret = __bsg_read(buf, count, bd, NULL, &bytes_read);
	@@ -621,7 +599,7 @@ bsg_read(struct file file, char __user buf, size_t count, loff_t *ppos)
	}		}

	static int __bsg_write(struct bsg_device bd, const char __user buf,		static int __bsg_write(struct bsg_device bd, const char __user buf,
	size_t count, ssize_t *bytes_written)		size_t count, ssize_t *bytes_written, int has_write_perm)
	{		{
	struct bsg_command *bc;		struct bsg_command *bc;
	struct request *rq;		struct request *rq;
	@@ -652,7 +630,7 @@ static int __bsg_write(struct bsg_device bd, const char __user buf,
	/*		/*
	* get a request, fill in the blanks, and add to request queue		* get a request, fill in the blanks, and add to request queue
	*/		*/
	rq = bsg_map_hdr(bd, &bc->hdr);		rq = bsg_map_hdr(bd, &bc->hdr, has_write_perm);
	if (IS_ERR(rq)) {		if (IS_ERR(rq)) {
	ret = PTR_ERR(rq);		ret = PTR_ERR(rq);
	rq = NULL;		rq = NULL;
	@@ -683,10 +661,11 @@ bsg_write(struct file file, const char __user buf, size_t count, loff_t *ppos)
	dprintk("%s: write %Zd bytes\n", bd->name, count);		dprintk("%s: write %Zd bytes\n", bd->name, count);

	bsg_set_block(bd, file);		bsg_set_block(bd, file);
	bsg_set_cmd_filter(bd, file);

	bytes_written = 0;		bytes_written = 0;
	ret = __bsg_write(bd, buf, count, &bytes_written);		ret = __bsg_write(bd, buf, count, &bytes_written,
			file->f_mode & FMODE_WRITE);

	*ppos = bytes_written;		*ppos = bytes_written;

	/*		/*
	@@ -792,7 +771,6 @@ static struct bsg_device bsg_add_device(struct inode inode,
	bd->queue = rq;		bd->queue = rq;

	bsg_set_block(bd, file);		bsg_set_block(bd, file);
	bsg_set_cmd_filter(bd, file);

	atomic_set(&bd->ref_count, 1);		atomic_set(&bd->ref_count, 1);
	mutex_lock(&bsg_mutex);		mutex_lock(&bsg_mutex);
	@@ -943,7 +921,7 @@ static long bsg_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
	if (copy_from_user(&hdr, uarg, sizeof(hdr)))		if (copy_from_user(&hdr, uarg, sizeof(hdr)))
	return -EFAULT;		return -EFAULT;

	rq = bsg_map_hdr(bd, &hdr);		rq = bsg_map_hdr(bd, &hdr, file->f_mode & FMODE_WRITE);
	if (IS_ERR(rq))		if (IS_ERR(rq))
	return PTR_ERR(rq);		return PTR_ERR(rq);

block/cmd-filter.c

+48 −148

Original line number	Original line	Diff line number	Diff line
	@@ -20,15 +20,14 @@
	#include <linux/list.h>		#include <linux/list.h>
	#include <linux/genhd.h>		#include <linux/genhd.h>
	#include <linux/spinlock.h>		#include <linux/spinlock.h>
	#include <linux/parser.h>
	#include <linux/capability.h>		#include <linux/capability.h>
	#include <linux/bitops.h>		#include <linux/bitops.h>

	#include <scsi/scsi.h>		#include <scsi/scsi.h>
	#include <linux/cdrom.h>		#include <linux/cdrom.h>

	int blk_cmd_filter_verify_command(struct blk_scsi_cmd_filter *filter,		int blk_verify_command(struct blk_cmd_filter *filter,
	unsigned char cmd, mode_t f_mode)		unsigned char *cmd, int has_write_perm)
	{		{
	/* root can do any command. */		/* root can do any command. */
	if (capable(CAP_SYS_RAWIO))		if (capable(CAP_SYS_RAWIO))
	@@ -43,34 +42,15 @@ int blk_cmd_filter_verify_command(struct blk_scsi_cmd_filter *filter,
	return 0;		return 0;

	/* Write-safe commands require a writable open */		/* Write-safe commands require a writable open */
	if (test_bit(cmd[0], filter->write_ok) && (*f_mode & FMODE_WRITE))		if (test_bit(cmd[0], filter->write_ok) && has_write_perm)
	return 0;		return 0;

	return -EPERM;		return -EPERM;
	}		}
	EXPORT_SYMBOL(blk_cmd_filter_verify_command);

	int blk_verify_command(struct file file, unsigned char cmd)
	{
	struct gendisk *disk;
	struct inode *inode;

	if (!file)
	return -EINVAL;

	inode = file->f_dentry->d_inode;
	if (!inode)
	return -EINVAL;

	disk = inode->i_bdev->bd_disk;

	return blk_cmd_filter_verify_command(&disk->cmd_filter,
	cmd, &file->f_mode);
	}
	EXPORT_SYMBOL(blk_verify_command);		EXPORT_SYMBOL(blk_verify_command);

	/* and now, the sysfs stuff */		/* and now, the sysfs stuff */
	static ssize_t rcf_cmds_show(struct blk_scsi_cmd_filter filter, char page,		static ssize_t rcf_cmds_show(struct blk_cmd_filter filter, char page,
	int rw)		int rw)
	{		{
	char *npage = page;		char *npage = page;
	@@ -84,8 +64,7 @@ static ssize_t rcf_cmds_show(struct blk_scsi_cmd_filter filter, char page,

	for (i = 0; i < BLK_SCSI_MAX_CMDS; i++) {		for (i = 0; i < BLK_SCSI_MAX_CMDS; i++) {
	if (test_bit(i, okbits)) {		if (test_bit(i, okbits)) {
	sprintf(npage, "%02x", i);		npage += sprintf(npage, "0x%02x", i);
	npage += 2;
	if (i < BLK_SCSI_MAX_CMDS - 1)		if (i < BLK_SCSI_MAX_CMDS - 1)
	sprintf(npage++, " ");		sprintf(npage++, " ");
	}		}
	@@ -97,57 +76,65 @@ static ssize_t rcf_cmds_show(struct blk_scsi_cmd_filter filter, char page,
	return npage - page;		return npage - page;
	}		}

	static ssize_t rcf_readcmds_show(struct blk_scsi_cmd_filter filter, char page)		static ssize_t rcf_readcmds_show(struct blk_cmd_filter filter, char page)
	{		{
	return rcf_cmds_show(filter, page, READ);		return rcf_cmds_show(filter, page, READ);
	}		}

	static ssize_t rcf_writecmds_show(struct blk_scsi_cmd_filter *filter,		static ssize_t rcf_writecmds_show(struct blk_cmd_filter *filter,
	char *page)		char *page)
	{		{
	return rcf_cmds_show(filter, page, WRITE);		return rcf_cmds_show(filter, page, WRITE);
	}		}

	static ssize_t rcf_cmds_store(struct blk_scsi_cmd_filter *filter,		static ssize_t rcf_cmds_store(struct blk_cmd_filter *filter,
	const char *page, size_t count, int rw)		const char *page, size_t count, int rw)
	{		{
	ssize_t ret = 0;
	unsigned long okbits[BLK_SCSI_CMD_PER_LONG], *target_okbits;		unsigned long okbits[BLK_SCSI_CMD_PER_LONG], *target_okbits;
	int cmd, status, len;		int cmd, set;
	substring_t ss;		char p, status;

	memset(&okbits, 0, sizeof(okbits));		if (rw == READ) {
			memcpy(&okbits, filter->read_ok, sizeof(okbits));
	for (len = strlen(page); len > 0; len -= 3) {		target_okbits = filter->read_ok;
	if (len < 2)		} else {
	break;		memcpy(&okbits, filter->write_ok, sizeof(okbits));
	ss.from = (char *) page + ret;		target_okbits = filter->write_ok;
	ss.to = (char *) page + ret + 2;		}
	ret += 3;
	status = match_hex(&ss, &cmd);		while ((p = strsep((char **)&page, " ")) != NULL) {
			set = 1;

			if (p[0] == '+') {
			p++;
			} else if (p[0] == '-') {
			set = 0;
			p++;
			}

			cmd = simple_strtol(p, &status, 16);

	/* either of these cases means invalid input, so do nothing. */		/* either of these cases means invalid input, so do nothing. */
	if (status \|\| cmd >= BLK_SCSI_MAX_CMDS)		if ((status == p) \|\| cmd >= BLK_SCSI_MAX_CMDS)
	return -EINVAL;		return -EINVAL;

			if (set)
	__set_bit(cmd, okbits);		__set_bit(cmd, okbits);
	}

	if (rw == READ)
	target_okbits = filter->read_ok;
	else		else
	target_okbits = filter->write_ok;		__clear_bit(cmd, okbits);
			}

	memmove(target_okbits, okbits, sizeof(okbits));		memcpy(target_okbits, okbits, sizeof(okbits));
	return count;		return count;
	}		}

	static ssize_t rcf_readcmds_store(struct blk_scsi_cmd_filter *filter,		static ssize_t rcf_readcmds_store(struct blk_cmd_filter *filter,
	const char *page, size_t count)		const char *page, size_t count)
	{		{
	return rcf_cmds_store(filter, page, count, READ);		return rcf_cmds_store(filter, page, count, READ);
	}		}

	static ssize_t rcf_writecmds_store(struct blk_scsi_cmd_filter *filter,		static ssize_t rcf_writecmds_store(struct blk_cmd_filter *filter,
	const char *page, size_t count)		const char *page, size_t count)
	{		{
	return rcf_cmds_store(filter, page, count, WRITE);		return rcf_cmds_store(filter, page, count, WRITE);
	@@ -155,8 +142,8 @@ static ssize_t rcf_writecmds_store(struct blk_scsi_cmd_filter *filter,

	struct rcf_sysfs_entry {		struct rcf_sysfs_entry {
	struct attribute attr;		struct attribute attr;
	ssize_t (show)(struct blk_scsi_cmd_filter , char *);		ssize_t (show)(struct blk_cmd_filter , char *);
	ssize_t (store)(struct blk_scsi_cmd_filter , const char *, size_t);		ssize_t (store)(struct blk_cmd_filter , const char *, size_t);
	};		};

	static struct rcf_sysfs_entry rcf_readcmds_entry = {		static struct rcf_sysfs_entry rcf_readcmds_entry = {
	@@ -183,9 +170,9 @@ static ssize_t
	rcf_attr_show(struct kobject kobj, struct attribute attr, char *page)		rcf_attr_show(struct kobject kobj, struct attribute attr, char *page)
	{		{
	struct rcf_sysfs_entry *entry = to_rcf(attr);		struct rcf_sysfs_entry *entry = to_rcf(attr);
	struct blk_scsi_cmd_filter *filter;		struct blk_cmd_filter *filter;

	filter = container_of(kobj, struct blk_scsi_cmd_filter, kobj);		filter = container_of(kobj, struct blk_cmd_filter, kobj);
	if (entry->show)		if (entry->show)
	return entry->show(filter, page);		return entry->show(filter, page);

	@@ -197,7 +184,7 @@ rcf_attr_store(struct kobject kobj, struct attribute attr,
	const char *page, size_t length)		const char *page, size_t length)
	{		{
	struct rcf_sysfs_entry *entry = to_rcf(attr);		struct rcf_sysfs_entry *entry = to_rcf(attr);
	struct blk_scsi_cmd_filter *filter;		struct blk_cmd_filter *filter;

	if (!capable(CAP_SYS_RAWIO))		if (!capable(CAP_SYS_RAWIO))
	return -EPERM;		return -EPERM;
	@@ -205,7 +192,7 @@ rcf_attr_store(struct kobject kobj, struct attribute attr,
	if (!entry->store)		if (!entry->store)
	return -EINVAL;		return -EINVAL;

	filter = container_of(kobj, struct blk_scsi_cmd_filter, kobj);		filter = container_of(kobj, struct blk_cmd_filter, kobj);
	return entry->store(filter, page, length);		return entry->store(filter, page, length);
	}		}

	@@ -219,96 +206,10 @@ static struct kobj_type rcf_ktype = {
	.default_attrs = default_attrs,		.default_attrs = default_attrs,
	};		};

	#ifndef MAINTENANCE_IN_CMD
	#define MAINTENANCE_IN_CMD 0xa3
	#endif

	static void rcf_set_defaults(struct blk_scsi_cmd_filter *filter)
	{
	/* Basic read-only commands */
	__set_bit(TEST_UNIT_READY, filter->read_ok);
	__set_bit(REQUEST_SENSE, filter->read_ok);
	__set_bit(READ_6, filter->read_ok);
	__set_bit(READ_10, filter->read_ok);
	__set_bit(READ_12, filter->read_ok);
	__set_bit(READ_16, filter->read_ok);
	__set_bit(READ_BUFFER, filter->read_ok);
	__set_bit(READ_DEFECT_DATA, filter->read_ok);
	__set_bit(READ_CAPACITY, filter->read_ok);
	__set_bit(READ_LONG, filter->read_ok);
	__set_bit(INQUIRY, filter->read_ok);
	__set_bit(MODE_SENSE, filter->read_ok);
	__set_bit(MODE_SENSE_10, filter->read_ok);
	__set_bit(LOG_SENSE, filter->read_ok);
	__set_bit(START_STOP, filter->read_ok);
	__set_bit(GPCMD_VERIFY_10, filter->read_ok);
	__set_bit(VERIFY_16, filter->read_ok);
	__set_bit(REPORT_LUNS, filter->read_ok);
	__set_bit(SERVICE_ACTION_IN, filter->read_ok);
	__set_bit(RECEIVE_DIAGNOSTIC, filter->read_ok);
	__set_bit(MAINTENANCE_IN_CMD, filter->read_ok);
	__set_bit(GPCMD_READ_BUFFER_CAPACITY, filter->read_ok);

	/* Audio CD commands */
	__set_bit(GPCMD_PLAY_CD, filter->read_ok);
	__set_bit(GPCMD_PLAY_AUDIO_10, filter->read_ok);
	__set_bit(GPCMD_PLAY_AUDIO_MSF, filter->read_ok);
	__set_bit(GPCMD_PLAY_AUDIO_TI, filter->read_ok);
	__set_bit(GPCMD_PAUSE_RESUME, filter->read_ok);

	/* CD/DVD data reading */
	__set_bit(GPCMD_READ_CD, filter->read_ok);
	__set_bit(GPCMD_READ_CD_MSF, filter->read_ok);
	__set_bit(GPCMD_READ_DISC_INFO, filter->read_ok);
	__set_bit(GPCMD_READ_CDVD_CAPACITY, filter->read_ok);
	__set_bit(GPCMD_READ_DVD_STRUCTURE, filter->read_ok);
	__set_bit(GPCMD_READ_HEADER, filter->read_ok);
	__set_bit(GPCMD_READ_TRACK_RZONE_INFO, filter->read_ok);
	__set_bit(GPCMD_READ_SUBCHANNEL, filter->read_ok);
	__set_bit(GPCMD_READ_TOC_PMA_ATIP, filter->read_ok);
	__set_bit(GPCMD_REPORT_KEY, filter->read_ok);
	__set_bit(GPCMD_SCAN, filter->read_ok);
	__set_bit(GPCMD_GET_CONFIGURATION, filter->read_ok);
	__set_bit(GPCMD_READ_FORMAT_CAPACITIES, filter->read_ok);
	__set_bit(GPCMD_GET_EVENT_STATUS_NOTIFICATION, filter->read_ok);
	__set_bit(GPCMD_GET_PERFORMANCE, filter->read_ok);
	__set_bit(GPCMD_SEEK, filter->read_ok);
	__set_bit(GPCMD_STOP_PLAY_SCAN, filter->read_ok);

	/* Basic writing commands */
	__set_bit(WRITE_6, filter->write_ok);
	__set_bit(WRITE_10, filter->write_ok);
	__set_bit(WRITE_VERIFY, filter->write_ok);
	__set_bit(WRITE_12, filter->write_ok);
	__set_bit(WRITE_VERIFY_12, filter->write_ok);
	__set_bit(WRITE_16, filter->write_ok);
	__set_bit(WRITE_LONG, filter->write_ok);
	__set_bit(WRITE_LONG_2, filter->write_ok);
	__set_bit(ERASE, filter->write_ok);
	__set_bit(GPCMD_MODE_SELECT_10, filter->write_ok);
	__set_bit(MODE_SELECT, filter->write_ok);
	__set_bit(LOG_SELECT, filter->write_ok);
	__set_bit(GPCMD_BLANK, filter->write_ok);
	__set_bit(GPCMD_CLOSE_TRACK, filter->write_ok);
	__set_bit(GPCMD_FLUSH_CACHE, filter->write_ok);
	__set_bit(GPCMD_FORMAT_UNIT, filter->write_ok);
	__set_bit(GPCMD_REPAIR_RZONE_TRACK, filter->write_ok);
	__set_bit(GPCMD_RESERVE_RZONE_TRACK, filter->write_ok);
	__set_bit(GPCMD_SEND_DVD_STRUCTURE, filter->write_ok);
	__set_bit(GPCMD_SEND_EVENT, filter->write_ok);
	__set_bit(GPCMD_SEND_KEY, filter->write_ok);
	__set_bit(GPCMD_SEND_OPC, filter->write_ok);
	__set_bit(GPCMD_SEND_CUE_SHEET, filter->write_ok);
	__set_bit(GPCMD_SET_SPEED, filter->write_ok);
	__set_bit(GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL, filter->write_ok);
	__set_bit(GPCMD_LOAD_UNLOAD, filter->write_ok);
	__set_bit(GPCMD_SET_STREAMING, filter->write_ok);
	}

	int blk_register_filter(struct gendisk *disk)		int blk_register_filter(struct gendisk *disk)
	{		{
	int ret;		int ret;
	struct blk_scsi_cmd_filter *filter = &disk->cmd_filter;		struct blk_cmd_filter *filter = &disk->queue->cmd_filter;
	struct kobject *parent = kobject_get(disk->holder_dir->parent);		struct kobject *parent = kobject_get(disk->holder_dir->parent);

	if (!parent)		if (!parent)
	@@ -320,13 +221,12 @@ int blk_register_filter(struct gendisk *disk)
	if (ret < 0)		if (ret < 0)
	return ret;		return ret;

	rcf_set_defaults(filter);
	return 0;		return 0;
	}		}

	void blk_unregister_filter(struct gendisk *disk)		void blk_unregister_filter(struct gendisk *disk)
	{		{
	struct blk_scsi_cmd_filter *filter = &disk->cmd_filter;		struct blk_cmd_filter *filter = &disk->queue->cmd_filter;

	kobject_put(&filter->kobj);		kobject_put(&filter->kobj);
	kobject_put(disk->holder_dir->parent);		kobject_put(disk->holder_dir->parent);

block/scsi_ioctl.c

+91 −3

Original line number	Original line	Diff line number	Diff line
	@@ -105,12 +105,96 @@ static int sg_emulated_host(struct request_queue q, int __user p)
	return put_user(1, p);		return put_user(1, p);
	}		}

			void blk_set_cmd_filter_defaults(struct blk_cmd_filter *filter)
			{
			/* Basic read-only commands */
			__set_bit(TEST_UNIT_READY, filter->read_ok);
			__set_bit(REQUEST_SENSE, filter->read_ok);
			__set_bit(READ_6, filter->read_ok);
			__set_bit(READ_10, filter->read_ok);
			__set_bit(READ_12, filter->read_ok);
			__set_bit(READ_16, filter->read_ok);
			__set_bit(READ_BUFFER, filter->read_ok);
			__set_bit(READ_DEFECT_DATA, filter->read_ok);
			__set_bit(READ_CAPACITY, filter->read_ok);
			__set_bit(READ_LONG, filter->read_ok);
			__set_bit(INQUIRY, filter->read_ok);
			__set_bit(MODE_SENSE, filter->read_ok);
			__set_bit(MODE_SENSE_10, filter->read_ok);
			__set_bit(LOG_SENSE, filter->read_ok);
			__set_bit(START_STOP, filter->read_ok);
			__set_bit(GPCMD_VERIFY_10, filter->read_ok);
			__set_bit(VERIFY_16, filter->read_ok);
			__set_bit(REPORT_LUNS, filter->read_ok);
			__set_bit(SERVICE_ACTION_IN, filter->read_ok);
			__set_bit(RECEIVE_DIAGNOSTIC, filter->read_ok);
			__set_bit(MAINTENANCE_IN, filter->read_ok);
			__set_bit(GPCMD_READ_BUFFER_CAPACITY, filter->read_ok);

			/* Audio CD commands */
			__set_bit(GPCMD_PLAY_CD, filter->read_ok);
			__set_bit(GPCMD_PLAY_AUDIO_10, filter->read_ok);
			__set_bit(GPCMD_PLAY_AUDIO_MSF, filter->read_ok);
			__set_bit(GPCMD_PLAY_AUDIO_TI, filter->read_ok);
			__set_bit(GPCMD_PAUSE_RESUME, filter->read_ok);

			/* CD/DVD data reading */
			__set_bit(GPCMD_READ_CD, filter->read_ok);
			__set_bit(GPCMD_READ_CD_MSF, filter->read_ok);
			__set_bit(GPCMD_READ_DISC_INFO, filter->read_ok);
			__set_bit(GPCMD_READ_CDVD_CAPACITY, filter->read_ok);
			__set_bit(GPCMD_READ_DVD_STRUCTURE, filter->read_ok);
			__set_bit(GPCMD_READ_HEADER, filter->read_ok);
			__set_bit(GPCMD_READ_TRACK_RZONE_INFO, filter->read_ok);
			__set_bit(GPCMD_READ_SUBCHANNEL, filter->read_ok);
			__set_bit(GPCMD_READ_TOC_PMA_ATIP, filter->read_ok);
			__set_bit(GPCMD_REPORT_KEY, filter->read_ok);
			__set_bit(GPCMD_SCAN, filter->read_ok);
			__set_bit(GPCMD_GET_CONFIGURATION, filter->read_ok);
			__set_bit(GPCMD_READ_FORMAT_CAPACITIES, filter->read_ok);
			__set_bit(GPCMD_GET_EVENT_STATUS_NOTIFICATION, filter->read_ok);
			__set_bit(GPCMD_GET_PERFORMANCE, filter->read_ok);
			__set_bit(GPCMD_SEEK, filter->read_ok);
			__set_bit(GPCMD_STOP_PLAY_SCAN, filter->read_ok);

			/* Basic writing commands */
			__set_bit(WRITE_6, filter->write_ok);
			__set_bit(WRITE_10, filter->write_ok);
			__set_bit(WRITE_VERIFY, filter->write_ok);
			__set_bit(WRITE_12, filter->write_ok);
			__set_bit(WRITE_VERIFY_12, filter->write_ok);
			__set_bit(WRITE_16, filter->write_ok);
			__set_bit(WRITE_LONG, filter->write_ok);
			__set_bit(WRITE_LONG_2, filter->write_ok);
			__set_bit(ERASE, filter->write_ok);
			__set_bit(GPCMD_MODE_SELECT_10, filter->write_ok);
			__set_bit(MODE_SELECT, filter->write_ok);
			__set_bit(LOG_SELECT, filter->write_ok);
			__set_bit(GPCMD_BLANK, filter->write_ok);
			__set_bit(GPCMD_CLOSE_TRACK, filter->write_ok);
			__set_bit(GPCMD_FLUSH_CACHE, filter->write_ok);
			__set_bit(GPCMD_FORMAT_UNIT, filter->write_ok);
			__set_bit(GPCMD_REPAIR_RZONE_TRACK, filter->write_ok);
			__set_bit(GPCMD_RESERVE_RZONE_TRACK, filter->write_ok);
			__set_bit(GPCMD_SEND_DVD_STRUCTURE, filter->write_ok);
			__set_bit(GPCMD_SEND_EVENT, filter->write_ok);
			__set_bit(GPCMD_SEND_KEY, filter->write_ok);
			__set_bit(GPCMD_SEND_OPC, filter->write_ok);
			__set_bit(GPCMD_SEND_CUE_SHEET, filter->write_ok);
			__set_bit(GPCMD_SET_SPEED, filter->write_ok);
			__set_bit(GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL, filter->write_ok);
			__set_bit(GPCMD_LOAD_UNLOAD, filter->write_ok);
			__set_bit(GPCMD_SET_STREAMING, filter->write_ok);
			}
			EXPORT_SYMBOL_GPL(blk_set_cmd_filter_defaults);

	static int blk_fill_sghdr_rq(struct request_queue q, struct request rq,		static int blk_fill_sghdr_rq(struct request_queue q, struct request rq,
	struct sg_io_hdr hdr, struct file file)		struct sg_io_hdr hdr, struct file file)
	{		{
	if (copy_from_user(rq->cmd, hdr->cmdp, hdr->cmd_len))		if (copy_from_user(rq->cmd, hdr->cmdp, hdr->cmd_len))
	return -EFAULT;		return -EFAULT;
	if (blk_verify_command(file, rq->cmd))		if (blk_verify_command(&q->cmd_filter, rq->cmd,
			file->f_mode & FMODE_WRITE))
	return -EPERM;		return -EPERM;

	/*		/*
	@@ -298,7 +382,7 @@ int sg_scsi_ioctl(struct file file, struct request_queue q,
	struct gendisk disk, struct scsi_ioctl_command __user sic)		struct gendisk disk, struct scsi_ioctl_command __user sic)
	{		{
	struct request *rq;		struct request *rq;
	int err;		int err, write_perm = 0;
	unsigned int in_len, out_len, bytes, opcode, cmdlen;		unsigned int in_len, out_len, bytes, opcode, cmdlen;
	char *buffer = NULL, sense[SCSI_SENSE_BUFFERSIZE];		char *buffer = NULL, sense[SCSI_SENSE_BUFFERSIZE];

	@@ -340,7 +424,11 @@ int sg_scsi_ioctl(struct file file, struct request_queue q,
	if (in_len && copy_from_user(buffer, sic->data + cmdlen, in_len))		if (in_len && copy_from_user(buffer, sic->data + cmdlen, in_len))
	goto error;		goto error;

	err = blk_verify_command(file, rq->cmd);		/* scsi_ioctl passes NULL */
			if (file && (file->f_mode & FMODE_WRITE))
			write_perm = 1;

			err = blk_verify_command(&q->cmd_filter, rq->cmd, write_perm);
	if (err)		if (err)
	goto error;		goto error;