mirror of
https://github.com/FEX-Emu/linux.git
synced 2024-12-14 12:49:08 +00:00
06a452e5b9
This patch adds the commands that the former sg filter allowed for read access to the cmdfilter to keep userspace apps that rely on them working. Signed-off-by: Adel Gadllah <adel.gadllah@gmail.com> Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
335 lines
9.3 KiB
C
335 lines
9.3 KiB
C
/*
|
|
* Copyright 2004 Peter M. Jones <pjones@redhat.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
*
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public Licens
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-
|
|
*
|
|
*/
|
|
|
|
#include <linux/list.h>
|
|
#include <linux/genhd.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/parser.h>
|
|
#include <linux/capability.h>
|
|
#include <linux/bitops.h>
|
|
|
|
#include <scsi/scsi.h>
|
|
#include <linux/cdrom.h>
|
|
|
|
int blk_cmd_filter_verify_command(struct blk_scsi_cmd_filter *filter,
|
|
unsigned char *cmd, mode_t *f_mode)
|
|
{
|
|
/* root can do any command. */
|
|
if (capable(CAP_SYS_RAWIO))
|
|
return 0;
|
|
|
|
/* if there's no filter set, assume we're filtering everything out */
|
|
if (!filter)
|
|
return -EPERM;
|
|
|
|
/* Anybody who can open the device can do a read-safe command */
|
|
if (test_bit(cmd[0], filter->read_ok))
|
|
return 0;
|
|
|
|
/* Write-safe commands require a writable open */
|
|
if (test_bit(cmd[0], filter->write_ok) && (*f_mode & FMODE_WRITE))
|
|
return 0;
|
|
|
|
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);
|
|
|
|
/* and now, the sysfs stuff */
|
|
static ssize_t rcf_cmds_show(struct blk_scsi_cmd_filter *filter, char *page,
|
|
int rw)
|
|
{
|
|
char *npage = page;
|
|
unsigned long *okbits;
|
|
int i;
|
|
|
|
if (rw == READ)
|
|
okbits = filter->read_ok;
|
|
else
|
|
okbits = filter->write_ok;
|
|
|
|
for (i = 0; i < BLK_SCSI_MAX_CMDS; i++) {
|
|
if (test_bit(i, okbits)) {
|
|
sprintf(npage, "%02x", i);
|
|
npage += 2;
|
|
if (i < BLK_SCSI_MAX_CMDS - 1)
|
|
sprintf(npage++, " ");
|
|
}
|
|
}
|
|
|
|
if (npage != page)
|
|
npage += sprintf(npage, "\n");
|
|
|
|
return npage - page;
|
|
}
|
|
|
|
static ssize_t rcf_readcmds_show(struct blk_scsi_cmd_filter *filter, char *page)
|
|
{
|
|
return rcf_cmds_show(filter, page, READ);
|
|
}
|
|
|
|
static ssize_t rcf_writecmds_show(struct blk_scsi_cmd_filter *filter,
|
|
char *page)
|
|
{
|
|
return rcf_cmds_show(filter, page, WRITE);
|
|
}
|
|
|
|
static ssize_t rcf_cmds_store(struct blk_scsi_cmd_filter *filter,
|
|
const char *page, size_t count, int rw)
|
|
{
|
|
ssize_t ret = 0;
|
|
unsigned long okbits[BLK_SCSI_CMD_PER_LONG], *target_okbits;
|
|
int cmd, status, len;
|
|
substring_t ss;
|
|
|
|
memset(&okbits, 0, sizeof(okbits));
|
|
|
|
for (len = strlen(page); len > 0; len -= 3) {
|
|
if (len < 2)
|
|
break;
|
|
ss.from = (char *) page + ret;
|
|
ss.to = (char *) page + ret + 2;
|
|
ret += 3;
|
|
status = match_hex(&ss, &cmd);
|
|
/* either of these cases means invalid input, so do nothing. */
|
|
if (status || cmd >= BLK_SCSI_MAX_CMDS)
|
|
return -EINVAL;
|
|
|
|
__set_bit(cmd, okbits);
|
|
}
|
|
|
|
if (rw == READ)
|
|
target_okbits = filter->read_ok;
|
|
else
|
|
target_okbits = filter->write_ok;
|
|
|
|
memmove(target_okbits, okbits, sizeof(okbits));
|
|
return count;
|
|
}
|
|
|
|
static ssize_t rcf_readcmds_store(struct blk_scsi_cmd_filter *filter,
|
|
const char *page, size_t count)
|
|
{
|
|
return rcf_cmds_store(filter, page, count, READ);
|
|
}
|
|
|
|
static ssize_t rcf_writecmds_store(struct blk_scsi_cmd_filter *filter,
|
|
const char *page, size_t count)
|
|
{
|
|
return rcf_cmds_store(filter, page, count, WRITE);
|
|
}
|
|
|
|
struct rcf_sysfs_entry {
|
|
struct attribute attr;
|
|
ssize_t (*show)(struct blk_scsi_cmd_filter *, char *);
|
|
ssize_t (*store)(struct blk_scsi_cmd_filter *, const char *, size_t);
|
|
};
|
|
|
|
static struct rcf_sysfs_entry rcf_readcmds_entry = {
|
|
.attr = { .name = "read_table", .mode = S_IRUGO | S_IWUSR },
|
|
.show = rcf_readcmds_show,
|
|
.store = rcf_readcmds_store,
|
|
};
|
|
|
|
static struct rcf_sysfs_entry rcf_writecmds_entry = {
|
|
.attr = {.name = "write_table", .mode = S_IRUGO | S_IWUSR },
|
|
.show = rcf_writecmds_show,
|
|
.store = rcf_writecmds_store,
|
|
};
|
|
|
|
static struct attribute *default_attrs[] = {
|
|
&rcf_readcmds_entry.attr,
|
|
&rcf_writecmds_entry.attr,
|
|
NULL,
|
|
};
|
|
|
|
#define to_rcf(atr) container_of((atr), struct rcf_sysfs_entry, attr)
|
|
|
|
static ssize_t
|
|
rcf_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
|
|
{
|
|
struct rcf_sysfs_entry *entry = to_rcf(attr);
|
|
struct blk_scsi_cmd_filter *filter;
|
|
|
|
filter = container_of(kobj, struct blk_scsi_cmd_filter, kobj);
|
|
if (entry->show)
|
|
return entry->show(filter, page);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t
|
|
rcf_attr_store(struct kobject *kobj, struct attribute *attr,
|
|
const char *page, size_t length)
|
|
{
|
|
struct rcf_sysfs_entry *entry = to_rcf(attr);
|
|
struct blk_scsi_cmd_filter *filter;
|
|
|
|
if (!capable(CAP_SYS_RAWIO))
|
|
return -EPERM;
|
|
|
|
if (!entry->store)
|
|
return -EINVAL;
|
|
|
|
filter = container_of(kobj, struct blk_scsi_cmd_filter, kobj);
|
|
return entry->store(filter, page, length);
|
|
}
|
|
|
|
static struct sysfs_ops rcf_sysfs_ops = {
|
|
.show = rcf_attr_show,
|
|
.store = rcf_attr_store,
|
|
};
|
|
|
|
static struct kobj_type rcf_ktype = {
|
|
.sysfs_ops = &rcf_sysfs_ops,
|
|
.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 ret;
|
|
struct blk_scsi_cmd_filter *filter = &disk->cmd_filter;
|
|
struct kobject *parent = kobject_get(disk->holder_dir->parent);
|
|
|
|
if (!parent)
|
|
return -ENODEV;
|
|
|
|
ret = kobject_init_and_add(&filter->kobj, &rcf_ktype, parent,
|
|
"%s", "cmd_filter");
|
|
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
rcf_set_defaults(filter);
|
|
return 0;
|
|
}
|
|
|
|
void blk_unregister_filter(struct gendisk *disk)
|
|
{
|
|
struct blk_scsi_cmd_filter *filter = &disk->cmd_filter;
|
|
|
|
kobject_put(&filter->kobj);
|
|
kobject_put(disk->holder_dir->parent);
|
|
}
|
|
|