lkml.org 
[lkml]   [2004]   [Sep]   [15]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    SubjectRe: [PATCH] allow root to modify raw scsi command permissions list
    From
    Date
    On Wed, 2004-09-15 at 00:43 +0200, Marc Ballarin wrote:
    > > +static struct disk_attribute disk_attribute_driver = {
    >
    > This obviously needs to be
    >
    > +static struct disk_attribute disk_attr_driver = {

    Absolutely right; I had this checked into my bk tree, but no cset made.
    That makes it not get exported, I guess...

    [...]
    > Additionally, the naming "rawio_cmd_filter" and RCF_* seems a bit
    > confusing (after all raw IO usually refers to O_DIRECT file access).
    > "sg_cmd_filter" and SGF_* appear to be a better choice IMHO.

    I could go either way on this; we use CAP_SYS_RAWIO to govern if root is
    getting access, but at the same time this really is scsi commands. I
    wonder Jens thinks, as he's the maintainer here...

    > How should changes to the table be made? I suppose something like "echo
    > add 04 > ok_read_commands". But rcf_store doesn't seem to get called. Am I
    > missing something?

    "add read 04", "del read 04", "add write 04", ...

    rcf_store() gets called as rcf_writecmds_entry.store() and
    rcf_readcommands_entry.store() . The get called from rcf_attr_store(),
    which gets called by sysfs as rcf_sysfs_ops.store()

    > Regards, and thanks for this patch

    Quite welcome. Here's an updated version with the attribute struct name
    fixed:

    diff -urpN linux-2.5-export/drivers/block/Makefile pjones-2.5-export/drivers/block/Makefile
    --- linux-2.5-export/drivers/block/Makefile 2004-09-15 12:42:18 -04:00
    +++ pjones-2.5-export/drivers/block/Makefile 2004-09-15 12:55:13 -04:00
    @@ -13,7 +13,7 @@
    # kblockd threads
    #

    -obj-y := elevator.o ll_rw_blk.o ioctl.o genhd.o scsi_ioctl.o
    +obj-y := elevator.o ll_rw_blk.o ioctl.o genhd.o scsi_ioctl.o rcf.o

    obj-$(CONFIG_IOSCHED_NOOP) += noop-iosched.o
    obj-$(CONFIG_IOSCHED_AS) += as-iosched.o
    diff -urpN linux-2.5-export/drivers/block/genhd.c pjones-2.5-export/drivers/block/genhd.c
    --- linux-2.5-export/drivers/block/genhd.c 2004-09-15 12:41:22 -04:00
    +++ pjones-2.5-export/drivers/block/genhd.c 2004-09-15 12:54:26 -04:00
    @@ -197,6 +197,7 @@ void add_disk(struct gendisk *disk)
    disk->minors, NULL, exact_match, exact_lock, disk);
    register_disk(disk);
    blk_register_queue(disk);
    + blk_register_filter(disk);
    }

    EXPORT_SYMBOL(add_disk);
    @@ -204,6 +205,7 @@ EXPORT_SYMBOL(del_gendisk); /* in partit

    void unlink_gendisk(struct gendisk *disk)
    {
    + blk_unregister_filter(disk);
    blk_unregister_queue(disk);
    blk_unregister_region(MKDEV(disk->major, disk->first_minor),
    disk->minors);
    @@ -382,6 +384,13 @@ static ssize_t disk_stats_read(struct ge
    jiffies_to_msecs(disk_stat_read(disk, io_ticks)),
    jiffies_to_msecs(disk_stat_read(disk, time_in_queue)));
    }
    +
    +static ssize_t disk_driver_read(struct gendisk * disk, char *page)
    +{
    + return sprintf(page, "%s\n", disk->disk_name);
    +
    +}
    +
    static struct disk_attribute disk_attr_dev = {
    .attr = {.name = "dev", .mode = S_IRUGO },
    .show = disk_dev_read
    @@ -402,6 +411,10 @@ static struct disk_attribute disk_attr_s
    .attr = {.name = "stat", .mode = S_IRUGO },
    .show = disk_stats_read
    };
    +static struct disk_attribute disk_attr_driver = {
    + .attr = {.name = "driver", .mode = S_IRUGO },
    + .show = disk_driver_read
    +};

    static struct attribute * default_attrs[] = {
    &disk_attr_dev.attr,
    @@ -409,6 +422,7 @@ static struct attribute * default_attrs[
    &disk_attr_removable.attr,
    &disk_attr_size.attr,
    &disk_attr_stat.attr,
    + &disk_attr_driver.attr,
    NULL,
    };

    diff -urpN linux-2.5-export/drivers/block/rcf.c pjones-2.5-export/drivers/block/rcf.c
    --- linux-2.5-export/drivers/block/rcf.c 1969-12-31 19:00:00 -05:00
    +++ pjones-2.5-export/drivers/block/rcf.c 2004-09-15 12:55:38 -04:00
    @@ -0,0 +1,322 @@
    +/*
    + * 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 <asm/bitops.h>
    +
    +#include <scsi/scsi.h>
    +#include <linux/cdrom.h>
    +
    +int rcf_verify_command(struct file *file, unsigned char *cmd)
    +{
    + struct rawio_cmd_filter *rcf;
    + struct inode *inode;
    +
    + inode = file->f_dentry->d_inode;
    + if (!inode)
    + return -EINVAL;
    +
    + rcf = &inode->i_bdev->bd_disk->filter;
    +
    + /* root can do any command. */
    + if (capable(CAP_SYS_RAWIO))
    + return 0;
    +
    + /* if there's no filter allocated, bail out. */
    + if (unlikely(!rcf))
    + return -EPERM;
    +
    + /* Anybody who can open the device can do a read-safe command */
    + if (test_bit(cmd[0], rcf->read_ok))
    + return 0;
    +
    + /* Write-safe commands require a writable open */
    + if (test_bit(cmd[0], rcf->write_ok))
    + if (file->f_mode & FMODE_WRITE)
    + return 0;
    +
    + /* Or else the user has no perms */
    + return -EPERM;
    +}
    +
    +EXPORT_SYMBOL(rcf_verify_command);
    +
    +/* and now, the sysfs stuff */
    +static ssize_t rcf_readcmds_show(struct rawio_cmd_filter *rcf, char *page)
    +{
    + char *npage = page;
    + int x;
    +
    + for (x=0; x < RCF_MAX_NR_CMDS; x++)
    + if (test_bit(x, rcf->read_ok)) {
    + sprintf(npage, "%02x", x);
    + npage += 2;
    + if (x < RCF_MAX_NR_CMDS-1)
    + sprintf(npage++, " ");
    + }
    + if (npage != page)
    + npage += sprintf(npage, "\n");
    +
    + return (npage - page);
    +}
    +
    +static ssize_t rcf_writecmds_show(struct rawio_cmd_filter *rcf, char *page)
    +{
    + char *npage = page;
    + int x;
    +
    + for (x=0; x < RCF_MAX_NR_CMDS; x++)
    + if (test_bit(x, rcf->write_ok)) {
    + sprintf(npage, "%02x", x);
    + npage += 2;
    + if (x < RCF_MAX_NR_CMDS-1)
    + sprintf(npage++, " ");
    + }
    + if (npage != page)
    + npage += sprintf(npage, "\n");
    +
    + return (npage - page);
    +}
    +
    +#define RCF_ADD 0
    +#define RCF_DEL 1
    +
    +static ssize_t rcf_store(struct rawio_cmd_filter *rcf, const char *page,
    + size_t count)
    +{
    + ssize_t ret=0;
    + int ad,rw;
    + int cmd, status;
    +
    + substring_t ss;
    +
    + if (!strncmp(page+ret, "add", 3)) {
    + ret += 3;
    + ad = RCF_ADD;
    + } else if (!strncmp(page+ret, "del", 3)) {
    + ret += 3;
    + ad = RCF_DEL;
    + } else
    + return -EINVAL;
    + if (page[ret++] == 0)
    + return -EINVAL;
    +
    + if (!strncmp(page+ret, "read", 4)) {
    + ret += 4;
    + rw = READ;
    + } else if (!strncmp(page+ret, "write", 5)) {
    + ret += 5;
    + rw = WRITE;
    + } else
    + return -EINVAL;
    + if (page[ret++] == 0)
    + return -EINVAL;
    +
    + ss.from = (char *)page+ret;
    + ss.to = ss.from + count - ret;
    + ret += count - ret;
    +
    + status = match_hex(&ss, &cmd);
    + if (status)
    + return status;
    + if (cmd > 256)
    + return -EINVAL;
    +
    + if (ad == RCF_ADD) {
    + if (rw == READ)
    + set_bit(cmd, rcf->read_ok);
    + else
    + set_bit(cmd, rcf->write_ok);
    + } else {
    + if (rw == READ)
    + clear_bit(cmd, rcf->read_ok);
    + else
    + clear_bit(cmd, rcf->write_ok);
    + }
    +
    + return count;
    +}
    +
    +struct rcf_sysfs_entry {
    + struct attribute attr;
    + ssize_t (*show)(struct rawio_cmd_filter *, char *);
    + ssize_t (*store)(struct rawio_cmd_filter *, const char *, size_t);
    +};
    +
    +static struct rcf_sysfs_entry rcf_readcmds_entry = {
    + .attr = {.name = "ok_read_commands", .mode = S_IRUGO | S_IWUSR },
    + .show = rcf_readcmds_show,
    + .store = rcf_store,
    +};
    +
    +static struct rcf_sysfs_entry rcf_writecmds_entry = {
    + .attr = {.name = "ok_write_commands", .mode = S_IRUGO | S_IWUSR },
    + .show = rcf_writecmds_show,
    + .store = rcf_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 rawio_cmd_filter *rcf;
    +
    + rcf = container_of(kobj, struct rawio_cmd_filter, kobj);
    + if (!entry->show)
    + return 0;
    +
    + return entry->show(rcf, page);
    +}
    +
    +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 rawio_cmd_filter *rcf;
    +
    + rcf = container_of(kobj, struct rawio_cmd_filter, kobj);
    + if (!entry->store)
    + return -EINVAL;
    +
    + return entry->store(rcf, 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,
    +};
    +
    +static void rcf_set_defaults(struct rawio_cmd_filter *rcf)
    +{
    + /* Basic read-only commands */
    + set_bit(TEST_UNIT_READY, rcf->read_ok);
    + set_bit(REQUEST_SENSE, rcf->read_ok);
    + set_bit(READ_6, rcf->read_ok);
    + set_bit(READ_10, rcf->read_ok);
    + set_bit(READ_12, rcf->read_ok);
    + set_bit(READ_16, rcf->read_ok);
    + set_bit(READ_BUFFER, rcf->read_ok);
    + set_bit(READ_LONG, rcf->read_ok);
    + set_bit(INQUIRY, rcf->read_ok);
    + set_bit(MODE_SENSE, rcf->read_ok);
    + set_bit(MODE_SENSE_10, rcf->read_ok);
    + set_bit(START_STOP, rcf->read_ok);
    + set_bit(GPCMD_VERIFY_10, rcf->read_ok);
    + set_bit(VERIFY_16, rcf->read_ok);
    + set_bit(READ_BUFFER, rcf->read_ok);
    +
    + /* Audio CD commands */
    + set_bit(GPCMD_PLAY_CD, rcf->read_ok);
    + set_bit(GPCMD_PLAY_AUDIO_10, rcf->read_ok);
    + set_bit(GPCMD_PLAY_AUDIO_MSF, rcf->read_ok);
    + set_bit(GPCMD_PLAY_AUDIO_TI, rcf->read_ok);
    + set_bit(GPCMD_PAUSE_RESUME, rcf->read_ok);
    +
    + /* CD/DVD data reading */
    + set_bit(GPCMD_READ_CD, rcf->read_ok);
    + set_bit(GPCMD_READ_CD_MSF, rcf->read_ok);
    + set_bit(GPCMD_READ_DISC_INFO, rcf->read_ok);
    + set_bit(GPCMD_READ_CDVD_CAPACITY, rcf->read_ok);
    + set_bit(GPCMD_READ_DVD_STRUCTURE, rcf->read_ok);
    + set_bit(GPCMD_READ_HEADER, rcf->read_ok);
    + set_bit(GPCMD_READ_TRACK_RZONE_INFO, rcf->read_ok);
    + set_bit(GPCMD_READ_SUBCHANNEL, rcf->read_ok);
    + set_bit(GPCMD_READ_TOC_PMA_ATIP, rcf->read_ok);
    + set_bit(GPCMD_REPORT_KEY, rcf->read_ok);
    + set_bit(GPCMD_SCAN, rcf->read_ok);
    + set_bit(GPCMD_GET_CONFIGURATION, rcf->read_ok);
    + set_bit(GPCMD_READ_FORMAT_CAPACITIES, rcf->read_ok);
    + set_bit(GPCMD_GET_EVENT_STATUS_NOTIFICATION, rcf->read_ok);
    + set_bit(GPCMD_GET_PERFORMANCE, rcf->read_ok);
    + set_bit(GPCMD_SEEK, rcf->read_ok);
    + set_bit(GPCMD_STOP_PLAY_SCAN, rcf->read_ok);
    +
    + /* Basic writing commands */
    + set_bit(WRITE_6, rcf->write_ok);
    + set_bit(WRITE_10, rcf->write_ok);
    + set_bit(WRITE_VERIFY, rcf->write_ok);
    + set_bit(WRITE_12, rcf->write_ok);
    + set_bit(WRITE_VERIFY_12, rcf->write_ok);
    + set_bit(WRITE_16, rcf->write_ok);
    + set_bit(WRITE_LONG, rcf->write_ok);
    + set_bit(ERASE, rcf->write_ok);
    + set_bit(GPCMD_MODE_SELECT_10, rcf->write_ok);
    + set_bit(MODE_SELECT, rcf->write_ok);
    + set_bit(GPCMD_BLANK, rcf->write_ok);
    + set_bit(GPCMD_CLOSE_TRACK, rcf->write_ok);
    + set_bit(GPCMD_FLUSH_CACHE, rcf->write_ok);
    + set_bit(GPCMD_FORMAT_UNIT, rcf->write_ok);
    + set_bit(GPCMD_REPAIR_RZONE_TRACK, rcf->write_ok);
    + set_bit(GPCMD_RESERVE_RZONE_TRACK, rcf->write_ok);
    + set_bit(GPCMD_SEND_DVD_STRUCTURE, rcf->write_ok);
    + set_bit(GPCMD_SEND_EVENT, rcf->write_ok);
    + set_bit(GPCMD_SEND_KEY, rcf->write_ok);
    + set_bit(GPCMD_SEND_OPC, rcf->write_ok);
    + set_bit(GPCMD_SEND_CUE_SHEET, rcf->write_ok);
    + set_bit(GPCMD_SET_SPEED, rcf->write_ok);
    + set_bit(GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL, rcf->write_ok);
    + set_bit(GPCMD_LOAD_UNLOAD, rcf->write_ok);
    + set_bit(GPCMD_SET_STREAMING, rcf->write_ok);
    +}
    +
    +int blk_register_filter(struct gendisk *disk)
    +{
    + int ret;
    + struct rawio_cmd_filter *rcf = &disk->filter;
    +
    + rcf->kobj.parent = kobject_get(&disk->kobj);
    + if (!rcf->kobj.parent)
    + return -EBUSY;
    +
    + snprintf(rcf->kobj.name, KOBJ_NAME_LEN, "%s", "filter");
    + rcf->kobj.ktype = &rcf_ktype;
    +
    + ret = kobject_register(&rcf->kobj);
    + if (ret < 0)
    + return ret;
    +
    + rcf_set_defaults(&disk->filter);
    +
    + return 0;
    +}
    +
    +void blk_unregister_filter(struct gendisk *disk)
    +{
    + struct rawio_cmd_filter *rcf = &disk->filter;
    +
    + kobject_unregister(&rcf->kobj);
    + kobject_put(&disk->kobj);
    +}
    diff -urpN linux-2.5-export/drivers/block/scsi_ioctl.c pjones-2.5-export/drivers/block/scsi_ioctl.c
    --- linux-2.5-export/drivers/block/scsi_ioctl.c 2004-09-15 12:42:48 -04:00
    +++ pjones-2.5-export/drivers/block/scsi_ioctl.c 2004-09-15 12:55:46 -04:00
    @@ -105,105 +105,6 @@ static int sg_emulated_host(request_queu
    return put_user(1, p);
    }

    -#define CMD_READ_SAFE 0x01
    -#define CMD_WRITE_SAFE 0x02
    -#define safe_for_read(cmd) [cmd] = CMD_READ_SAFE
    -#define safe_for_write(cmd) [cmd] = CMD_WRITE_SAFE
    -
    -static int verify_command(struct file *file, unsigned char *cmd)
    -{
    - static const unsigned char cmd_type[256] = {
    -
    - /* Basic read-only commands */
    - safe_for_read(TEST_UNIT_READY),
    - safe_for_read(REQUEST_SENSE),
    - safe_for_read(READ_6),
    - safe_for_read(READ_10),
    - safe_for_read(READ_12),
    - safe_for_read(READ_16),
    - safe_for_read(READ_BUFFER),
    - safe_for_read(READ_LONG),
    - safe_for_read(INQUIRY),
    - safe_for_read(MODE_SENSE),
    - safe_for_read(MODE_SENSE_10),
    - safe_for_read(START_STOP),
    - safe_for_read(GPCMD_VERIFY_10),
    - safe_for_read(VERIFY_16),
    - safe_for_read(READ_BUFFER),
    -
    - /* Audio CD commands */
    - safe_for_read(GPCMD_PLAY_CD),
    - safe_for_read(GPCMD_PLAY_AUDIO_10),
    - safe_for_read(GPCMD_PLAY_AUDIO_MSF),
    - safe_for_read(GPCMD_PLAY_AUDIO_TI),
    - safe_for_read(GPCMD_PAUSE_RESUME),
    -
    - /* CD/DVD data reading */
    - safe_for_read(GPCMD_READ_CD),
    - safe_for_read(GPCMD_READ_CD_MSF),
    - safe_for_read(GPCMD_READ_DISC_INFO),
    - safe_for_read(GPCMD_READ_CDVD_CAPACITY),
    - safe_for_read(GPCMD_READ_DVD_STRUCTURE),
    - safe_for_read(GPCMD_READ_HEADER),
    - safe_for_read(GPCMD_READ_TRACK_RZONE_INFO),
    - safe_for_read(GPCMD_READ_SUBCHANNEL),
    - safe_for_read(GPCMD_READ_TOC_PMA_ATIP),
    - safe_for_read(GPCMD_REPORT_KEY),
    - safe_for_read(GPCMD_SCAN),
    - safe_for_read(GPCMD_GET_CONFIGURATION),
    - safe_for_read(GPCMD_READ_FORMAT_CAPACITIES),
    - safe_for_read(GPCMD_GET_EVENT_STATUS_NOTIFICATION),
    - safe_for_read(GPCMD_GET_PERFORMANCE),
    - safe_for_read(GPCMD_SEEK),
    - safe_for_read(GPCMD_STOP_PLAY_SCAN),
    -
    - /* Basic writing commands */
    - safe_for_write(WRITE_6),
    - safe_for_write(WRITE_10),
    - safe_for_write(WRITE_VERIFY),
    - safe_for_write(WRITE_12),
    - safe_for_write(WRITE_VERIFY_12),
    - safe_for_write(WRITE_16),
    - safe_for_write(WRITE_LONG),
    - safe_for_write(ERASE),
    - safe_for_write(GPCMD_MODE_SELECT_10),
    - safe_for_write(MODE_SELECT),
    - safe_for_write(GPCMD_BLANK),
    - safe_for_write(GPCMD_CLOSE_TRACK),
    - safe_for_write(GPCMD_FLUSH_CACHE),
    - safe_for_write(GPCMD_FORMAT_UNIT),
    - safe_for_write(GPCMD_REPAIR_RZONE_TRACK),
    - safe_for_write(GPCMD_RESERVE_RZONE_TRACK),
    - safe_for_write(GPCMD_SEND_DVD_STRUCTURE),
    - safe_for_write(GPCMD_SEND_EVENT),
    - safe_for_write(GPCMD_SEND_KEY),
    - safe_for_write(GPCMD_SEND_OPC),
    - safe_for_write(GPCMD_SEND_CUE_SHEET),
    - safe_for_write(GPCMD_SET_SPEED),
    - safe_for_write(GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL),
    - safe_for_write(GPCMD_LOAD_UNLOAD),
    - safe_for_write(GPCMD_SET_STREAMING),
    - };
    - unsigned char type = cmd_type[cmd[0]];
    -
    - /* Anybody who can open the device can do a read-safe command */
    - if (type & CMD_READ_SAFE)
    - return 0;
    -
    - /* Write-safe commands just require a writable open.. */
    - if (type & CMD_WRITE_SAFE) {
    - if (file->f_mode & FMODE_WRITE)
    - return 0;
    - }
    -
    - /* And root can do any command.. */
    - if (capable(CAP_SYS_RAWIO))
    - return 0;
    -
    - /* Otherwise fail it with an "Operation not permitted" */
    - return -EPERM;
    -}
    -
    static int sg_io(struct file *file, request_queue_t *q,
    struct gendisk *bd_disk, struct sg_io_hdr *hdr)
    {
    @@ -220,7 +121,7 @@ static int sg_io(struct file *file, requ
    return -EINVAL;
    if (copy_from_user(cmd, hdr->cmdp, hdr->cmd_len))
    return -EFAULT;
    - if (verify_command(file, cmd))
    + if (rcf_verify_command(file, cmd))
    return -EPERM;

    /*
    @@ -370,7 +271,7 @@ static int sg_scsi_ioctl(struct file *fi
    if (copy_from_user(buffer, sic->data + cmdlen, in_len))
    goto error;

    - err = verify_command(file, rq->cmd);
    + err = rcf_verify_command(file, rq->cmd);
    if (err)
    goto error;

    diff -urpN linux-2.5-export/include/linux/blkdev.h pjones-2.5-export/include/linux/blkdev.h
    --- linux-2.5-export/include/linux/blkdev.h 2004-09-15 12:40:23 -04:00
    +++ pjones-2.5-export/include/linux/blkdev.h 2004-09-15 12:53:55 -04:00
    @@ -513,6 +513,8 @@ struct sec_size {
    unsigned block_size_bits;
    };

    +extern int blk_register_filter(struct gendisk *disk);
    +extern void blk_unregister_filter(struct gendisk *disk);
    extern int blk_register_queue(struct gendisk *disk);
    extern void blk_unregister_queue(struct gendisk *disk);
    extern void register_disk(struct gendisk *dev);
    diff -urpN linux-2.5-export/include/linux/genhd.h pjones-2.5-export/include/linux/genhd.h
    --- linux-2.5-export/include/linux/genhd.h 2004-09-15 12:39:54 -04:00
    +++ pjones-2.5-export/include/linux/genhd.h 2004-09-15 12:53:44 -04:00
    @@ -78,6 +78,15 @@ struct disk_stats {
    unsigned io_ticks;
    unsigned time_in_queue;
    };
    +
    +#define RCF_MAX_NR_CMDS 256
    +#define RCF_CMD_BYTES (RCF_MAX_NR_CMDS / (sizeof (unsigned long) * 8))
    +
    +struct rawio_cmd_filter {
    + unsigned long read_ok[RCF_CMD_BYTES];
    + unsigned long write_ok[RCF_CMD_BYTES];
    + struct kobject kobj;
    +};

    struct gendisk {
    int major; /* major number of driver */
    @@ -88,6 +97,7 @@ struct gendisk {
    struct hd_struct **part; /* [indexed by minor] */
    struct block_device_operations *fops;
    struct request_queue *queue;
    + struct rawio_cmd_filter filter;
    void *private_data;
    sector_t capacity;

    --
    Peter

    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

    \
     
     \ /
      Last update: 2005-03-22 14:06    [W:5.509 / U:0.012 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site