2 * Copyright 2004 Peter M. Jones <pjones@redhat.com>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public Licens
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-
20 #include <linux/list.h>
21 #include <linux/genhd.h>
22 #include <linux/spinlock.h>
23 #include <linux/parser.h>
24 #include <linux/capability.h>
25 #include <linux/bitops.h>
27 #include <scsi/scsi.h>
28 #include <linux/cdrom.h>
30 int blk_verify_command(struct blk_cmd_filter *filter,
31 unsigned char *cmd, int has_write_perm)
33 /* root can do any command. */
34 if (capable(CAP_SYS_RAWIO))
37 /* if there's no filter set, assume we're filtering everything out */
41 /* Anybody who can open the device can do a read-safe command */
42 if (test_bit(cmd[0], filter->read_ok))
45 /* Write-safe commands require a writable open */
46 if (test_bit(cmd[0], filter->write_ok) && has_write_perm)
51 EXPORT_SYMBOL(blk_verify_command);
53 /* and now, the sysfs stuff */
54 static ssize_t rcf_cmds_show(struct blk_cmd_filter *filter, char *page,
58 unsigned long *okbits;
62 okbits = filter->read_ok;
64 okbits = filter->write_ok;
66 for (i = 0; i < BLK_SCSI_MAX_CMDS; i++) {
67 if (test_bit(i, okbits)) {
68 sprintf(npage, "%02x", i);
70 if (i < BLK_SCSI_MAX_CMDS - 1)
71 sprintf(npage++, " ");
76 npage += sprintf(npage, "\n");
81 static ssize_t rcf_readcmds_show(struct blk_cmd_filter *filter, char *page)
83 return rcf_cmds_show(filter, page, READ);
86 static ssize_t rcf_writecmds_show(struct blk_cmd_filter *filter,
89 return rcf_cmds_show(filter, page, WRITE);
92 static ssize_t rcf_cmds_store(struct blk_cmd_filter *filter,
93 const char *page, size_t count, int rw)
96 unsigned long okbits[BLK_SCSI_CMD_PER_LONG], *target_okbits;
100 memset(&okbits, 0, sizeof(okbits));
102 for (len = strlen(page); len > 0; len -= 3) {
105 ss.from = (char *) page + ret;
106 ss.to = (char *) page + ret + 2;
108 status = match_hex(&ss, &cmd);
109 /* either of these cases means invalid input, so do nothing. */
110 if (status || cmd >= BLK_SCSI_MAX_CMDS)
113 __set_bit(cmd, okbits);
117 target_okbits = filter->read_ok;
119 target_okbits = filter->write_ok;
121 memmove(target_okbits, okbits, sizeof(okbits));
125 static ssize_t rcf_readcmds_store(struct blk_cmd_filter *filter,
126 const char *page, size_t count)
128 return rcf_cmds_store(filter, page, count, READ);
131 static ssize_t rcf_writecmds_store(struct blk_cmd_filter *filter,
132 const char *page, size_t count)
134 return rcf_cmds_store(filter, page, count, WRITE);
137 struct rcf_sysfs_entry {
138 struct attribute attr;
139 ssize_t (*show)(struct blk_cmd_filter *, char *);
140 ssize_t (*store)(struct blk_cmd_filter *, const char *, size_t);
143 static struct rcf_sysfs_entry rcf_readcmds_entry = {
144 .attr = { .name = "read_table", .mode = S_IRUGO | S_IWUSR },
145 .show = rcf_readcmds_show,
146 .store = rcf_readcmds_store,
149 static struct rcf_sysfs_entry rcf_writecmds_entry = {
150 .attr = {.name = "write_table", .mode = S_IRUGO | S_IWUSR },
151 .show = rcf_writecmds_show,
152 .store = rcf_writecmds_store,
155 static struct attribute *default_attrs[] = {
156 &rcf_readcmds_entry.attr,
157 &rcf_writecmds_entry.attr,
161 #define to_rcf(atr) container_of((atr), struct rcf_sysfs_entry, attr)
164 rcf_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
166 struct rcf_sysfs_entry *entry = to_rcf(attr);
167 struct blk_cmd_filter *filter;
169 filter = container_of(kobj, struct blk_cmd_filter, kobj);
171 return entry->show(filter, page);
177 rcf_attr_store(struct kobject *kobj, struct attribute *attr,
178 const char *page, size_t length)
180 struct rcf_sysfs_entry *entry = to_rcf(attr);
181 struct blk_cmd_filter *filter;
183 if (!capable(CAP_SYS_RAWIO))
189 filter = container_of(kobj, struct blk_cmd_filter, kobj);
190 return entry->store(filter, page, length);
193 static struct sysfs_ops rcf_sysfs_ops = {
194 .show = rcf_attr_show,
195 .store = rcf_attr_store,
198 static struct kobj_type rcf_ktype = {
199 .sysfs_ops = &rcf_sysfs_ops,
200 .default_attrs = default_attrs,
203 int blk_register_filter(struct gendisk *disk)
206 struct blk_cmd_filter *filter = &disk->queue->cmd_filter;
207 struct kobject *parent = kobject_get(disk->holder_dir->parent);
212 ret = kobject_init_and_add(&filter->kobj, &rcf_ktype, parent,
221 void blk_unregister_filter(struct gendisk *disk)
223 struct blk_cmd_filter *filter = &disk->queue->cmd_filter;
225 kobject_put(&filter->kobj);
226 kobject_put(disk->holder_dir->parent);