Release 4.11 drivers/scsi/scsi_sysfs.c

/*
 * scsi_sysfs.c
 *
 * SCSI sysfs interface routines.
 *
 * Created to pull SCSI mid layer sysfs routines into one file.
 */

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/blkdev.h>
#include <linux/device.h>
#include <linux/pm_runtime.h>

#include <scsi/scsi.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_tcq.h>
#include <scsi/scsi_dh.h>
#include <scsi/scsi_transport.h>
#include <scsi/scsi_driver.h>

#include "scsi_priv.h"
#include "scsi_logging.h"


static struct device_type scsi_dev_type;

static const struct {
	
enum scsi_device_state	value;
	
char			*name;
} 
sdev_states[] = {
	{ SDEV_CREATED, "created" },
	{ SDEV_RUNNING, "running" },
	{ SDEV_CANCEL, "cancel" },
	{ SDEV_DEL, "deleted" },
	{ SDEV_QUIESCE, "quiesce" },
	{ SDEV_OFFLINE,	"offline" },
	{ SDEV_TRANSPORT_OFFLINE, "transport-offline" },
	{ SDEV_BLOCK,	"blocked" },
	{ SDEV_CREATED_BLOCK, "created-blocked" },
};



const char *scsi_device_state_name(enum scsi_device_state state)
{
	int i;
	char *name = NULL;

	for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
		if (sdev_states[i].value == state) {
			name = sdev_states[i].name;
			break;
		}
	}
	return name;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
James Bottomley
63
98.44%
1
50.00%
Tobias Klauser
1
1.56%
1
50.00%
Total
64
100.00%
2
100.00%

static const struct {
	
enum scsi_host_state	value;
	
char			*name;
} 
shost_states[] = {
	{ SHOST_CREATED, "created" },
	{ SHOST_RUNNING, "running" },
	{ SHOST_CANCEL, "cancel" },
	{ SHOST_DEL, "deleted" },
	{ SHOST_RECOVERY, "recovery" },
	{ SHOST_CANCEL_RECOVERY, "cancel/recovery" },
	{ SHOST_DEL_RECOVERY, "deleted/recovery", },
};


const char *scsi_host_state_name(enum scsi_host_state state)
{
	int i;
	char *name = NULL;

	for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
		if (shost_states[i].value == state) {
			name = shost_states[i].name;
			break;
		}
	}
	return name;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mike Anderson
63
98.44%
1
50.00%
Tobias Klauser
1
1.56%
1
50.00%
Total
64
100.00%
2
100.00%

#ifdef CONFIG_SCSI_DH
static const struct {
	
unsigned char	value;
	
char		*name;
} 
sdev_access_states[] = {
	{ SCSI_ACCESS_STATE_OPTIMAL, "active/optimized" },
	{ SCSI_ACCESS_STATE_ACTIVE, "active/non-optimized" },
	{ SCSI_ACCESS_STATE_STANDBY, "standby" },
	{ SCSI_ACCESS_STATE_UNAVAILABLE, "unavailable" },
	{ SCSI_ACCESS_STATE_LBA, "lba-dependent" },
	{ SCSI_ACCESS_STATE_OFFLINE, "offline" },
	{ SCSI_ACCESS_STATE_TRANSITIONING, "transitioning" },
};



static const char *scsi_access_state_name(unsigned char state)
{
	int i;
	char *name = NULL;

	for (i = 0; i < ARRAY_SIZE(sdev_access_states); i++) {
		if (sdev_access_states[i].value == state) {
			name = sdev_access_states[i].name;
			break;
		}
	}
	return name;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Hannes Reinecke
64
98.46%
1
50.00%
Bart Van Assche
1
1.54%
1
50.00%
Total
65
100.00%
2
100.00%

#endif



static int check_set(unsigned long long *val, char *src)
{
	char *last;

	if (strncmp(src, "-", 20) == 0) {
		*val = SCAN_WILD_CARD;
	} else {
		/*
                 * Doesn't check for int overflow
                 */
		*val = simple_strtoull(src, &last, 0);
		if (*last != '\0')
			return 1;
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Patrick Mansfield
67
95.71%
1
50.00%
Hannes Reinecke
3
4.29%
1
50.00%
Total
70
100.00%
2
100.00%



static int scsi_scan(struct Scsi_Host *shost, const char *str)
{
	char s1[15], s2[15], s3[17], junk;
	unsigned long long channel, id, lun;
	int res;

	res = sscanf(str, "%10s %10s %16s %c", s1, s2, s3, &junk);
	if (res != 3)
		return -EINVAL;
	if (check_set(&channel, s1))
		return -EINVAL;
	if (check_set(&id, s2))
		return -EINVAL;
	if (check_set(&lun, s3))
		return -EINVAL;
	if (shost->transportt->user_scan)
		res = shost->transportt->user_scan(shost, channel, id, lun);
	else
		res = scsi_scan_host_selected(shost, channel, id, lun,
					      SCSI_SCAN_MANUAL);
	return res;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Patrick Mansfield
129
80.62%
1
25.00%
Christoph Hellwig
26
16.25%
1
25.00%
Hannes Reinecke
5
3.12%
2
50.00%
Total
160
100.00%
4
100.00%

/*
 * shost_show_function: macro to create an attr function that can be used to
 * show a non-bit field.
 */

#define shost_show_function(name, field, format_string)			\
static ssize_t                                                          \
show_##name (struct device *dev, struct device_attribute *attr,         \
             char *buf)                                                 \
{                                                                       \
        struct Scsi_Host *shost = class_to_shost(dev);                  \
        return snprintf (buf, 20, format_string, shost->field);         \
}

/*
 * shost_rd_attr: macro to create a function and attribute variable for a
 * read only field.
 */

#define shost_rd_attr2(name, field, format_string)			\
	shost_show_function(name, field, format_string)                 \
static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);


#define shost_rd_attr(field, format_string) \
shost_rd_attr2(field, field, format_string)

/*
 * Create the actual show/store functions and data structures.
 */


static ssize_t

store_scan(struct device *dev, struct device_attribute *attr,
	   const char *buf, size_t count)
{
	struct Scsi_Host *shost = class_to_shost(dev);
	int res;

	res = scsi_scan(shost, buf);
	if (res == 0)
		res = count;
	return res;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Patrick Mansfield
51
86.44%
1
50.00%
Tony Jones
8
13.56%
1
50.00%
Total
59
100.00%
2
100.00%

;
static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);


static ssize_t

store_shost_state(struct device *dev, struct device_attribute *attr,
		  const char *buf, size_t count)
{
	int i;
	struct Scsi_Host *shost = class_to_shost(dev);
	enum scsi_host_state state = 0;

	for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
		const int len = strlen(shost_states[i].name);
		if (strncmp(shost_states[i].name, buf, len) == 0 &&
		   buf[len] == '\n') {
			state = shost_states[i].value;
			break;
		}
	}
	if (!state)
		return -EINVAL;

	if (scsi_host_set_state(shost, state))
		return -EINVAL;
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mike Anderson
128
93.43%
1
33.33%
Tony Jones
8
5.84%
1
33.33%
Tobias Klauser
1
0.73%
1
33.33%
Total
137
100.00%
3
100.00%


static ssize_t

show_shost_state(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct Scsi_Host *shost = class_to_shost(dev);
	const char *name = scsi_host_state_name(shost->shost_state);

	if (!name)
		return -EINVAL;

	return snprintf(buf, 20, "%s\n", name);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mike Anderson
55
87.30%
1
50.00%
Tony Jones
8
12.70%
1
50.00%
Total
63
100.00%
2
100.00%

/* DEVICE_ATTR(state) clashes with dev_attr_state for sdev */

static struct device_attribute dev_attr_hstate =
	__ATTR(state, S_IRUGO | S_IWUSR, show_shost_state, store_shost_state);


static ssize_t

show_shost_mode(unsigned int mode, char *buf)
{
	ssize_t len = 0;

	if (mode & MODE_INITIATOR)
		len = sprintf(buf, "%s", "Initiator");

	if (mode & MODE_TARGET)
		len += sprintf(buf + len, "%s%s", len ? ", " : "", "Target");

	len += sprintf(buf + len, "\n");

	return len;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
FUJITA Tomonori
75
100.00%
1
100.00%
Total
75
100.00%
1
100.00%


static ssize_t

show_shost_supported_mode(struct device *dev, struct device_attribute *attr,
			  char *buf)
{
	struct Scsi_Host *shost = class_to_shost(dev);
	unsigned int supported_mode = shost->hostt->supported_mode;

	if (supported_mode == MODE_UNKNOWN)
		/* by default this should be initiator */
		supported_mode = MODE_INITIATOR;

	return show_shost_mode(supported_mode, buf);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
FUJITA Tomonori
38
64.41%
1
33.33%
James Bottomley
13
22.03%
1
33.33%
Tony Jones
8
13.56%
1
33.33%
Total
59
100.00%
3
100.00%

static DEVICE_ATTR(supported_mode, S_IRUGO | S_IWUSR, show_shost_supported_mode, NULL);


static ssize_t

show_shost_active_mode(struct device *dev,
		       struct device_attribute *attr, char *buf)
{
	struct Scsi_Host *shost = class_to_shost(dev);

	if (shost->active_mode == MODE_UNKNOWN)
		return snprintf(buf, 20, "unknown\n");
	else
		return show_shost_mode(shost->active_mode, buf);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
FUJITA Tomonori
51
86.44%
1
50.00%
Tony Jones
8
13.56%
1
50.00%
Total
59
100.00%
2
100.00%

static DEVICE_ATTR(active_mode, S_IRUGO | S_IWUSR, show_shost_active_mode, NULL);



static int check_reset_type(const char *str)
{
	if (sysfs_streq(str, "adapter"))
		return SCSI_ADAPTER_RESET;
	else if (sysfs_streq(str, "firmware"))
		return SCSI_FIRMWARE_RESET;
	else
		return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Vikas Chaudhary
37
92.50%
1
50.00%
Sasha Levin
3
7.50%
1
50.00%
Total
40
100.00%
2
100.00%


static ssize_t

store_host_reset(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t count)
{
	struct Scsi_Host *shost = class_to_shost(dev);
	struct scsi_host_template *sht = shost->hostt;
	int ret = -EINVAL;
	int type;

	type = check_reset_type(buf);
	if (!type)
		goto exit_store_host_reset;

	if (sht->host_reset)
		ret = sht->host_reset(shost, type);

exit_store_host_reset:
	if (ret == 0)
		ret = count;
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Vikas Chaudhary
98
98.99%
1
50.00%
Sasha Levin
1
1.01%
1
50.00%
Total
99
100.00%
2
100.00%

static DEVICE_ATTR(host_reset, S_IWUSR, NULL, store_host_reset);


static ssize_t

show_shost_eh_deadline(struct device *dev,
		      struct device_attribute *attr, char *buf)
{
	struct Scsi_Host *shost = class_to_shost(dev);

	if (shost->eh_deadline == -1)
		return snprintf(buf, strlen("off") + 2, "off\n");
	return sprintf(buf, "%u\n", shost->eh_deadline / HZ);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Hannes Reinecke
43
63.24%
1
50.00%
Ren Mingxin
25
36.76%
1
50.00%
Total
68
100.00%
2
100.00%


static ssize_t

store_shost_eh_deadline(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t count)
{
	struct Scsi_Host *shost = class_to_shost(dev);
	int ret = -EINVAL;
	unsigned long deadline, flags;

	if (shost->transportt &&
	    (shost->transportt->eh_strategy_handler ||
	     !shost->hostt->eh_host_reset_handler))
		return ret;

	if (!strncmp(buf, "off", strlen("off")))
		deadline = -1;
	else {
		ret = kstrtoul(buf, 10, &deadline);
		if (ret)
			return ret;
		if (deadline * HZ > UINT_MAX)
			return -EINVAL;
	}

	spin_lock_irqsave(shost->host_lock, flags);
	if (scsi_host_in_recovery(shost))
		ret = -EBUSY;
	else {
		if (deadline == -1)
			shost->eh_deadline = -1;
		else
			shost->eh_deadline = deadline * HZ;

		ret = count;
	}
	spin_unlock_irqrestore(shost->host_lock, flags);

	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Hannes Reinecke
126
67.38%
2
66.67%
Ren Mingxin
61
32.62%
1
33.33%
Total
187
100.00%
3
100.00%

static DEVICE_ATTR(eh_deadline, S_IRUGO | S_IWUSR, show_shost_eh_deadline, store_shost_eh_deadline);

shost_rd_attr(use_blk_mq, "%d\n");
shost_rd_attr(unique_id, "%u\n");
shost_rd_attr(cmd_per_lun, "%hd\n");
shost_rd_attr(can_queue, "%hd\n");
shost_rd_attr(sg_tablesize, "%hu\n");
shost_rd_attr(sg_prot_tablesize, "%hu\n");
shost_rd_attr(unchecked_isa_dma, "%d\n");
shost_rd_attr(prot_capabilities, "%u\n");
shost_rd_attr(prot_guard_type, "%hd\n");
shost_rd_attr2(proc_name, hostt->proc_name, "%s\n");


static ssize_t

show_host_busy(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct Scsi_Host *shost = class_to_shost(dev);
	return snprintf(buf, 20, "%d\n", atomic_read(&shost->host_busy));
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Christoph Hellwig
48
100.00%
1
100.00%
Total
48
100.00%
1
100.00%

static DEVICE_ATTR(host_busy, S_IRUGO, show_host_busy, NULL);


static struct attribute *scsi_sysfs_shost_attrs[] = {
	&dev_attr_use_blk_mq.attr,
	&dev_attr_unique_id.attr,
	&dev_attr_host_busy.attr,
	&dev_attr_cmd_per_lun.attr,
	&dev_attr_can_queue.attr,
	&dev_attr_sg_tablesize.attr,
	&dev_attr_sg_prot_tablesize.attr,
	&dev_attr_unchecked_isa_dma.attr,
	&dev_attr_proc_name.attr,
	&dev_attr_scan.attr,
	&dev_attr_hstate.attr,
	&dev_attr_supported_mode.attr,
	&dev_attr_active_mode.attr,
	&dev_attr_prot_capabilities.attr,
	&dev_attr_prot_guard_type.attr,
	&dev_attr_host_reset.attr,
	&dev_attr_eh_deadline.attr,
	NULL
};


static struct attribute_group scsi_shost_attr_group = {
	.attrs =	scsi_sysfs_shost_attrs,
};


const struct attribute_group *scsi_sysfs_shost_attr_groups[] = {
	&scsi_shost_attr_group,
	NULL
};



static void scsi_device_cls_release(struct device *class_dev)
{
	struct scsi_device *sdev;

	sdev = class_to_sdev(class_dev);
	put_device(&sdev->sdev_gendev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mike Anderson
30
96.77%
1
50.00%
Tony Jones
1
3.23%
1
50.00%
Total
31
100.00%
2
100.00%



static void scsi_device_dev_release_usercontext(struct work_struct *work)
{
	struct scsi_device *sdev;
	struct device *parent;
	struct list_head *this, *tmp;
	unsigned long flags;

	sdev = container_of(work, struct scsi_device, ew.work);

	scsi_dh_release_device(sdev);

	parent = sdev->sdev_gendev.parent;

	spin_lock_irqsave(sdev->host->host_lock, flags);
	list_del(&sdev->siblings);
	list_del(&sdev->same_target_siblings);
	list_del(&sdev->starved_entry);
	spin_unlock_irqrestore(sdev->host->host_lock, flags);

	cancel_work_sync(&sdev->event_work);

	list_for_each_safe(this, tmp, &sdev->event_list) {
		struct scsi_event *evt;

		evt = list_entry(this, struct scsi_event, node);
		list_del(&evt->node);
		kfree(evt);
	}

	blk_put_queue(sdev->request_queue);
	/* NULL queue means the device can't be used */
	sdev->request_queue = NULL;

	kfree(sdev->vpd_pg83);
	kfree(sdev->vpd_pg80);
	kfree(sdev->inquiry);
	kfree(sdev);

	if (parent)
		put_device(parent);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mike Anderson
82
40.39%
2
15.38%
Jeff Garzik
55
27.09%
1
7.69%
James Bottomley
33
16.26%
6
46.15%
David Howells
20
9.85%
1
7.69%
Hannes Reinecke
7
3.45%
1
7.69%
Jun'ichi Nomura
5
2.46%
1
7.69%
Adrian Bunk
1
0.49%
1
7.69%
Total
203
100.00%
13
100.00%



static void scsi_device_dev_release(struct device *dev)
{
	struct scsi_device *sdp = to_scsi_device(dev);
	execute_in_process_context(scsi_device_dev_release_usercontext,
				   &sdp->ew);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
James Bottomley
31
100.00%
2
100.00%
Total
31
100.00%
2
100.00%


static struct class sdev_class = {
	.name		= "scsi_device",
	.dev_release	= scsi_device_cls_release,
};

/* all probing is done in the individual ->probe routines */


static int scsi_bus_match(struct device *dev, struct device_driver *gendrv)
{
	struct scsi_device *sdp;

	if (dev->type != &scsi_dev_type)
		return 0;

	sdp = to_scsi_device(dev);
	if (sdp->no_uld_attach)
		return 0;
	return (sdp->inq_periph_qual == SCSI_INQ_PQ_CON)? 1: 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mike Anderson
18
29.03%
1
20.00%
Kurt Garloff
18
29.03%
1
20.00%
Hannes Reinecke
16
25.81%
1
20.00%
James Bottomley
9
14.52%
1
20.00%
Christoph Hellwig
1
1.61%
1
20.00%
Total
62
100.00%
5
100.00%



static int scsi_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
{
	struct scsi_device *sdev;

	if (dev->type != &scsi_dev_type)
		return 0;

	sdev = to_scsi_device(dev);

	add_uevent_var(env, "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT, sdev->type);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Michael Tokarev
35
63.64%
1
33.33%
James Bottomley
16
29.09%
1
33.33%
Kay Sievers
4
7.27%
1
33.33%
Total
55
100.00%
3
100.00%


struct bus_type scsi_bus_type = {
        .name		= "scsi",
        .match		= scsi_bus_match,
	.uevent		= scsi_bus_uevent,
#ifdef CONFIG_PM
	.pm		= &scsi_bus_pm_ops,
#endif
};

EXPORT_SYMBOL_GPL(scsi_bus_type);



int scsi_sysfs_register(void)
{
	int error;

	error = bus_register(&scsi_bus_type);
	if (!error) {
		error = class_register(&sdev_class);
		if (error)
			bus_unregister(&scsi_bus_type);
	}

	return error;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mike Anderson
29
63.04%
2
50.00%
Christoph Hellwig
17
36.96%
2
50.00%
Total
46
100.00%
4
100.00%



void scsi_sysfs_unregister(void)
{
	class_unregister(&sdev_class);
	bus_unregister(&scsi_bus_type);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mike Anderson
10
52.63%
1
50.00%
Christoph Hellwig
9
47.37%
1
50.00%
Total
19
100.00%
2
100.00%

/*
 * sdev_show_function: macro to create an attr function that can be used to
 * show a non-bit field.
 */

#define sdev_show_function(field, format_string)				\
static ssize_t                                                          \
sdev_show_##field (struct device *dev, struct device_attribute *attr,   \
                   char *buf)                                           \
{                                                                       \
        struct scsi_device *sdev;                                       \
        sdev = to_scsi_device(dev);                                     \
        return snprintf (buf, 20, format_string, sdev->field);          \
}									\

/*
 * sdev_rd_attr: macro to create a function and attribute variable for a
 * read only field.
 */

#define sdev_rd_attr(field, format_string)				\
	sdev_show_function(field, format_string)                        \
static DEVICE_ATTR(field, S_IRUGO, sdev_show_##field, NULL);


/*
 * sdev_rw_attr: create a function and attribute variable for a
 * read/write field.
 */

#define sdev_rw_attr(field, format_string)				\
	sdev_show_function(field, format_string)                                \
                                                                        \
static ssize_t                                                          \
sdev_store_##field (struct device *dev, struct device_attribute *attr,  \
                    const char *buf, size_t count)                      \
{                                                                       \
        struct scsi_device *sdev;                                       \
        sdev = to_scsi_device(dev);                                     \
        sscanf (buf, format_string, &sdev->field);                      \
        return count;                                                   \
}                                                                       \
static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);

/* Currently we don't export bit fields, but we might in future,
 * so leave this code in */
#if 0
/*
 * sdev_rd_attr: create a function and attribute variable for a
 * read/write bit field.
 */
#define sdev_rw_attr_bit(field)						\
	sdev_show_function(field, "%d\n")                                       \
                                                                        \
static ssize_t                                                          \
sdev_store_##field (struct device *dev, struct device_attribute *attr,  \
                    const char *buf, size_t count)                      \
{                                                                       \
        int ret;                                                        \
        struct scsi_device *sdev;                                       \
        ret = scsi_sdev_check_buf_bit(buf);                             \
        if (ret >= 0)   {                                               \
                sdev = to_scsi_device(dev);                             \
                sdev->field = ret;                                      \
                ret = count;                                            \
        }                                                               \
        return ret;                                                     \
}                                                                       \
static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);

/*
 * scsi_sdev_check_buf_bit: return 0 if buf is "0", return 1 if buf is "1",
 * else return -EINVAL.
 */
static int scsi_sdev_check_buf_bit(const char *buf)
{
        if ((buf[1] == '\0') || ((buf[1] == '\n') && (buf[2] == '\0'))) {
                if (buf[0] == '1')
                        return 1;
                else if (buf[0] == '0')
                        return 0;
                else 
                        return -EINVAL;
        } else
                return -EINVAL;
}
#endif
/*
 * Create the actual show/store functions and data structures.
 */
sdev_rd_attr (type, "%d\n");
sdev_rd_attr (scsi_level, "%d\n");
sdev_rd_attr (vendor, "%.8s\n");
sdev_rd_attr (model, "%.16s\n");
sdev_rd_attr (rev, "%.4s\n");


static ssize_t

sdev_show_device_busy(struct device *dev, struct device_attribute *attr,
		char *buf)
{
	struct scsi_device *sdev = to_scsi_device(dev);
	return snprintf(buf, 20, "%d\n", atomic_read(&sdev->device_busy));
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Christoph Hellwig
48
100.00%
1
100.00%
Total
48
100.00%
1
100.00%

static DEVICE_ATTR(device_busy, S_IRUGO, sdev_show_device_busy, NULL);


static ssize_t

sdev_show_device_blocked(struct device *dev, struct device_attribute *attr,
		char *buf)
{
	struct scsi_device *sdev = to_scsi_device(dev);
	return snprintf(buf, 20, "%d\n", atomic_read(&sdev->device_blocked));
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Christoph Hellwig
48
100.00%
1
100.00%
Total
48
100.00%
1
100.00%

static DEVICE_ATTR(device_blocked, S_IRUGO, sdev_show_device_blocked, NULL);

/*
 * TODO: can we make these symlinks to the block layer ones?
 */

static ssize_t

sdev_show_timeout (struct device *dev, struct device_attribute *attr, char *buf)
{
	struct scsi_device *sdev;
	sdev = to_scsi_device(dev);
	return snprintf(buf, 20, "%d\n", sdev->request_queue->rq_timeout / HZ);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Brian King
40
80.00%
1
20.00%
Yani Ioannou
5
10.00%
1
20.00%
Jens Axboe
3
6.00%
1
20.00%
Patrick Mansfield
1
2.00%
1
20.00%
Alex Tomas
1
2.00%
1
20.00%
Total
50
100.00%
5
100.00%


static ssize_t

sdev_store_timeout (struct device *dev, struct device_attribute *attr,
		    const char *buf, size_t count)
{
	struct scsi_device *sdev;
	int timeout;
	sdev = to_scsi_device(dev);
	sscanf (buf, "%d\n", &timeout);
	blk_queue_rq_timeout(sdev->request_queue, timeout * HZ);
	return count;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Brian King
30
47.62%
1
16.67%
Alex Tomas
21
33.33%
1
16.67%
Yani Ioannou
5
7.94%
1
16.67%
Jens Axboe
5
7.94%
1
16.67%
Patrick Mansfield
1
1.59%
1
16.67%
Christoph Hellwig
1
1.59%
1
16.67%
Total
63
100.00%
6
100.00%

static DEVICE_ATTR(timeout, S_IRUGO | S_IWUSR, sdev_show_timeout, sdev_store_timeout);


static ssize_t

sdev_show_eh_timeout(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct scsi_device *sdev;
	sdev = to_scsi_device(dev);
	return snprintf(buf, 20, "%u\n", sdev->eh_timeout / HZ);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin K. Petersen
46
95.83%
1
50.00%
Brian King
2
4.17%
1
50.00%
Total
48
100.00%
2
100.00%


static ssize_t

sdev_store_eh_timeout(struct device *dev, struct device_attribute *attr,
		    const char *buf, size_t count)
{
	struct scsi_device *sdev;
	unsigned int eh_timeout;
	int err;

	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;

	sdev = to_scsi_device(dev);
	err = kstrtouint(buf, 10, &eh_timeout);
	if (err)
		return err;
	sdev->eh_timeout = eh_timeout * HZ;

	return count;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin K. Petersen
85
100.00%
1
100.00%
Total
85
100.00%
1
100.00%

static DEVICE_ATTR(eh_timeout, S_IRUGO | S_IWUSR, sdev_show_eh_timeout, sdev_store_eh_timeout);


static ssize_t

store_rescan_field (struct device *dev, struct device_attribute *attr,
		    const char