scsi_sysfs.c 37.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9
/*
 * scsi_sysfs.c
 *
 * SCSI sysfs interface routines.
 *
 * Created to pull SCSI mid layer sysfs routines into one file.
 */

#include <linux/module.h>
10
#include <linux/slab.h>
L
Linus Torvalds 已提交
11 12 13
#include <linux/init.h>
#include <linux/blkdev.h>
#include <linux/device.h>
14
#include <linux/pm_runtime.h>
L
Linus Torvalds 已提交
15 16 17 18 19

#include <scsi/scsi.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_tcq.h>
20
#include <scsi/scsi_dh.h>
L
Linus Torvalds 已提交
21
#include <scsi/scsi_transport.h>
A
Adrian Bunk 已提交
22
#include <scsi/scsi_driver.h>
L
Linus Torvalds 已提交
23 24 25 26

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

27 28
static struct device_type scsi_dev_type;

29
static const struct {
L
Linus Torvalds 已提交
30 31 32 33 34 35 36 37 38
	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" },
39
	{ SDEV_TRANSPORT_OFFLINE, "transport-offline" },
L
Linus Torvalds 已提交
40
	{ SDEV_BLOCK,	"blocked" },
41
	{ SDEV_CREATED_BLOCK, "created-blocked" },
L
Linus Torvalds 已提交
42 43 44 45 46 47 48
};

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

49
	for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
L
Linus Torvalds 已提交
50 51 52 53 54 55 56 57
		if (sdev_states[i].value == state) {
			name = sdev_states[i].name;
			break;
		}
	}
	return name;
}

58
static const struct {
59 60 61 62 63 64 65 66
	enum scsi_host_state	value;
	char			*name;
} shost_states[] = {
	{ SHOST_CREATED, "created" },
	{ SHOST_RUNNING, "running" },
	{ SHOST_CANCEL, "cancel" },
	{ SHOST_DEL, "deleted" },
	{ SHOST_RECOVERY, "recovery" },
67 68
	{ SHOST_CANCEL_RECOVERY, "cancel/recovery" },
	{ SHOST_DEL_RECOVERY, "deleted/recovery", },
69 70 71 72 73 74
};
const char *scsi_host_state_name(enum scsi_host_state state)
{
	int i;
	char *name = NULL;

75
	for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
76 77 78 79 80 81 82 83
		if (shost_states[i].value == state) {
			name = shost_states[i].name;
			break;
		}
	}
	return name;
}

84
#ifdef CONFIG_SCSI_DH
85 86 87 88 89 90 91 92 93 94 95 96 97
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" },
};

98
static const char *scsi_access_state_name(unsigned char state)
99 100 101 102 103 104 105 106 107 108 109 110
{
	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;
}
111
#endif
112

H
Hannes Reinecke 已提交
113
static int check_set(unsigned long long *val, char *src)
L
Linus Torvalds 已提交
114 115 116 117 118 119 120 121 122
{
	char *last;

	if (strncmp(src, "-", 20) == 0) {
		*val = SCAN_WILD_CARD;
	} else {
		/*
		 * Doesn't check for int overflow
		 */
H
Hannes Reinecke 已提交
123
		*val = simple_strtoull(src, &last, 0);
L
Linus Torvalds 已提交
124 125 126 127 128 129 130 131
		if (*last != '\0')
			return 1;
	}
	return 0;
}

static int scsi_scan(struct Scsi_Host *shost, const char *str)
{
H
Hannes Reinecke 已提交
132 133
	char s1[15], s2[15], s3[17], junk;
	unsigned long long channel, id, lun;
L
Linus Torvalds 已提交
134 135
	int res;

H
Hannes Reinecke 已提交
136
	res = sscanf(str, "%10s %10s %16s %c", s1, s2, s3, &junk);
L
Linus Torvalds 已提交
137 138 139 140 141 142 143 144
	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;
145 146 147 148
	if (shost->transportt->user_scan)
		res = shost->transportt->user_scan(shost, channel, id, lun);
	else
		res = scsi_scan_host_selected(shost, channel, id, lun, 1);
L
Linus Torvalds 已提交
149 150 151 152 153 154 155 156 157
	return res;
}

/*
 * 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								\
158 159
show_##name (struct device *dev, struct device_attribute *attr, 	\
	     char *buf)							\
L
Linus Torvalds 已提交
160
{									\
161
	struct Scsi_Host *shost = class_to_shost(dev);			\
L
Linus Torvalds 已提交
162 163 164 165 166 167 168 169 170
	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)			\
171
static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
L
Linus Torvalds 已提交
172 173 174 175 176 177 178 179

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

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

180 181 182
static ssize_t
store_scan(struct device *dev, struct device_attribute *attr,
	   const char *buf, size_t count)
L
Linus Torvalds 已提交
183
{
184
	struct Scsi_Host *shost = class_to_shost(dev);
L
Linus Torvalds 已提交
185 186 187 188 189 190 191
	int res;

	res = scsi_scan(shost, buf);
	if (res == 0)
		res = count;
	return res;
};
192
static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);
L
Linus Torvalds 已提交
193

194
static ssize_t
195 196
store_shost_state(struct device *dev, struct device_attribute *attr,
		  const char *buf, size_t count)
197 198
{
	int i;
199
	struct Scsi_Host *shost = class_to_shost(dev);
200 201
	enum scsi_host_state state = 0;

202
	for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
		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;
}

static ssize_t
219
show_shost_state(struct device *dev, struct device_attribute *attr, char *buf)
220
{
221
	struct Scsi_Host *shost = class_to_shost(dev);
222 223 224 225 226 227 228 229
	const char *name = scsi_host_state_name(shost->shost_state);

	if (!name)
		return -EINVAL;

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

230
/* DEVICE_ATTR(state) clashes with dev_attr_state for sdev */
231
static struct device_attribute dev_attr_hstate =
232
	__ATTR(state, S_IRUGO | S_IWUSR, show_shost_state, store_shost_state);
233

234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
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;
}

250 251 252
static ssize_t
show_shost_supported_mode(struct device *dev, struct device_attribute *attr,
			  char *buf)
253
{
254
	struct Scsi_Host *shost = class_to_shost(dev);
255
	unsigned int supported_mode = shost->hostt->supported_mode;
256

257 258 259 260 261
	if (supported_mode == MODE_UNKNOWN)
		/* by default this should be initiator */
		supported_mode = MODE_INITIATOR;

	return show_shost_mode(supported_mode, buf);
262 263
}

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

266 267 268
static ssize_t
show_shost_active_mode(struct device *dev,
		       struct device_attribute *attr, char *buf)
269
{
270
	struct Scsi_Host *shost = class_to_shost(dev);
271 272 273 274 275 276 277

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

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

280
static int check_reset_type(const char *str)
281
{
282
	if (sysfs_streq(str, "adapter"))
283
		return SCSI_ADAPTER_RESET;
284
	else if (sysfs_streq(str, "firmware"))
285 286 287 288 289 290 291 292 293 294 295 296 297 298
		return SCSI_FIRMWARE_RESET;
	else
		return 0;
}

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;

299
	type = check_reset_type(buf);
300 301 302 303 304 305 306 307 308 309 310 311 312 313
	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;
}

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

314 315 316 317 318 319
static ssize_t
show_shost_eh_deadline(struct device *dev,
		      struct device_attribute *attr, char *buf)
{
	struct Scsi_Host *shost = class_to_shost(dev);

320 321 322
	if (shost->eh_deadline == -1)
		return snprintf(buf, strlen("off") + 2, "off\n");
	return sprintf(buf, "%u\n", shost->eh_deadline / HZ);
323 324 325 326 327 328 329 330
}

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;
331
	unsigned long deadline, flags;
332

333 334 335
	if (shost->transportt &&
	    (shost->transportt->eh_strategy_handler ||
	     !shost->hostt->eh_host_reset_handler))
336 337
		return ret;

338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
	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
355
			shost->eh_deadline = deadline * HZ;
356 357

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

361 362 363 364 365
	return ret;
}

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

366
shost_rd_attr(use_blk_mq, "%d\n");
L
Linus Torvalds 已提交
367 368
shost_rd_attr(unique_id, "%u\n");
shost_rd_attr(cmd_per_lun, "%hd\n");
369
shost_rd_attr(can_queue, "%hd\n");
L
Linus Torvalds 已提交
370
shost_rd_attr(sg_tablesize, "%hu\n");
371
shost_rd_attr(sg_prot_tablesize, "%hu\n");
L
Linus Torvalds 已提交
372
shost_rd_attr(unchecked_isa_dma, "%d\n");
373 374
shost_rd_attr(prot_capabilities, "%u\n");
shost_rd_attr(prot_guard_type, "%hd\n");
L
Linus Torvalds 已提交
375 376
shost_rd_attr2(proc_name, hostt->proc_name, "%s\n");

377 378 379 380 381 382 383 384
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));
}
static DEVICE_ATTR(host_busy, S_IRUGO, show_host_busy, NULL);

385
static struct attribute *scsi_sysfs_shost_attrs[] = {
386
	&dev_attr_use_blk_mq.attr,
387 388 389 390 391
	&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,
392
	&dev_attr_sg_prot_tablesize.attr,
393 394 395 396 397 398
	&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,
399 400
	&dev_attr_prot_capabilities.attr,
	&dev_attr_prot_guard_type.attr,
401
	&dev_attr_host_reset.attr,
402
	&dev_attr_eh_deadline.attr,
403 404 405
	NULL
};

406
static struct attribute_group scsi_shost_attr_group = {
407 408 409
	.attrs =	scsi_sysfs_shost_attrs,
};

410
const struct attribute_group *scsi_sysfs_shost_attr_groups[] = {
411
	&scsi_shost_attr_group,
L
Linus Torvalds 已提交
412 413 414
	NULL
};

415
static void scsi_device_cls_release(struct device *class_dev)
L
Linus Torvalds 已提交
416 417 418 419 420 421 422
{
	struct scsi_device *sdev;

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

423
static void scsi_device_dev_release_usercontext(struct work_struct *work)
L
Linus Torvalds 已提交
424 425 426
{
	struct scsi_device *sdev;
	struct device *parent;
427
	struct list_head *this, *tmp;
L
Linus Torvalds 已提交
428 429
	unsigned long flags;

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

432 433
	scsi_dh_release_device(sdev);

434
	parent = sdev->sdev_gendev.parent;
L
Linus Torvalds 已提交
435 436 437 438 439 440 441

	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);

442 443 444 445 446 447 448 449 450 451
	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);
	}

452
	blk_put_queue(sdev->request_queue);
453 454
	/* NULL queue means the device can't be used */
	sdev->request_queue = NULL;
L
Linus Torvalds 已提交
455

456 457
	kfree(sdev->vpd_pg83);
	kfree(sdev->vpd_pg80);
L
Linus Torvalds 已提交
458 459 460 461 462 463 464
	kfree(sdev->inquiry);
	kfree(sdev);

	if (parent)
		put_device(parent);
}

465 466
static void scsi_device_dev_release(struct device *dev)
{
467
	struct scsi_device *sdp = to_scsi_device(dev);
468
	execute_in_process_context(scsi_device_dev_release_usercontext,
469
				   &sdp->ew);
470 471
}

A
Adrian Bunk 已提交
472
static struct class sdev_class = {
L
Linus Torvalds 已提交
473
	.name		= "scsi_device",
474
	.dev_release	= scsi_device_cls_release,
L
Linus Torvalds 已提交
475 476 477 478 479
};

/* all probing is done in the individual ->probe routines */
static int scsi_bus_match(struct device *dev, struct device_driver *gendrv)
{
480 481 482 483 484 485
	struct scsi_device *sdp;

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

	sdp = to_scsi_device(dev);
L
Linus Torvalds 已提交
486 487 488 489 490
	if (sdp->no_uld_attach)
		return 0;
	return (sdp->inq_periph_qual == SCSI_INQ_PQ_CON)? 1: 0;
}

491
static int scsi_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
492
{
493 494 495 496 497 498
	struct scsi_device *sdev;

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

	sdev = to_scsi_device(dev);
499

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

L
Linus Torvalds 已提交
504 505 506
struct bus_type scsi_bus_type = {
        .name		= "scsi",
        .match		= scsi_bus_match,
507
	.uevent		= scsi_bus_uevent,
R
Rafael J. Wysocki 已提交
508
#ifdef CONFIG_PM
509
	.pm		= &scsi_bus_pm_ops,
510
#endif
L
Linus Torvalds 已提交
511
};
512
EXPORT_SYMBOL_GPL(scsi_bus_type);
L
Linus Torvalds 已提交
513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539

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;
}

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

/*
 * 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								\
540 541
sdev_show_##field (struct device *dev, struct device_attribute *attr,	\
		   char *buf)						\
L
Linus Torvalds 已提交
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557
{									\
	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);


/*
558
 * sdev_rw_attr: create a function and attribute variable for a
L
Linus Torvalds 已提交
559 560 561 562 563 564
 * read/write field.
 */
#define sdev_rw_attr(field, format_string)				\
	sdev_show_function(field, format_string)				\
									\
static ssize_t								\
565 566
sdev_store_##field (struct device *dev, struct device_attribute *attr,	\
		    const char *buf, size_t count)			\
L
Linus Torvalds 已提交
567 568 569
{									\
	struct scsi_device *sdev;					\
	sdev = to_scsi_device(dev);					\
570
	sscanf (buf, format_string, &sdev->field);			\
L
Linus Torvalds 已提交
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
	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								\
586 587
sdev_store_##field (struct device *dev, struct device_attribute *attr,	\
		    const char *buf, size_t count)			\
L
Linus Torvalds 已提交
588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
{									\
	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");

627 628 629 630 631 632 633 634 635
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));
}
static DEVICE_ATTR(device_busy, S_IRUGO, sdev_show_device_busy, NULL);

636 637 638 639 640 641 642 643 644
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));
}
static DEVICE_ATTR(device_blocked, S_IRUGO, sdev_show_device_blocked, NULL);

J
Jens Axboe 已提交
645 646 647
/*
 * TODO: can we make these symlinks to the block layer ones?
 */
L
Linus Torvalds 已提交
648
static ssize_t
649
sdev_show_timeout (struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
650 651 652
{
	struct scsi_device *sdev;
	sdev = to_scsi_device(dev);
J
Jens Axboe 已提交
653
	return snprintf(buf, 20, "%d\n", sdev->request_queue->rq_timeout / HZ);
L
Linus Torvalds 已提交
654 655 656
}

static ssize_t
657 658
sdev_store_timeout (struct device *dev, struct device_attribute *attr,
		    const char *buf, size_t count)
L
Linus Torvalds 已提交
659 660 661 662 663
{
	struct scsi_device *sdev;
	int timeout;
	sdev = to_scsi_device(dev);
	sscanf (buf, "%d\n", &timeout);
J
Jens Axboe 已提交
664
	blk_queue_rq_timeout(sdev->request_queue, timeout * HZ);
L
Linus Torvalds 已提交
665 666 667 668
	return count;
}
static DEVICE_ATTR(timeout, S_IRUGO | S_IWUSR, sdev_show_timeout, sdev_store_timeout);

669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697
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);
}

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;
}
static DEVICE_ATTR(eh_timeout, S_IRUGO | S_IWUSR, sdev_show_eh_timeout, sdev_store_eh_timeout);

L
Linus Torvalds 已提交
698
static ssize_t
699 700
store_rescan_field (struct device *dev, struct device_attribute *attr,
		    const char *buf, size_t count)
L
Linus Torvalds 已提交
701 702 703 704 705 706
{
	scsi_rescan_device(dev);
	return count;
}
static DEVICE_ATTR(rescan, S_IWUSR, NULL, store_rescan_field);

707 708 709
static ssize_t
sdev_store_delete(struct device *dev, struct device_attribute *attr,
		  const char *buf, size_t count)
L
Linus Torvalds 已提交
710
{
711 712
	if (device_remove_file_self(dev, attr))
		scsi_remove_device(to_scsi_device(dev));
L
Linus Torvalds 已提交
713 714 715 716 717
	return count;
};
static DEVICE_ATTR(delete, S_IWUSR, NULL, sdev_store_delete);

static ssize_t
718 719
store_state_field(struct device *dev, struct device_attribute *attr,
		  const char *buf, size_t count)
L
Linus Torvalds 已提交
720 721 722 723 724
{
	int i;
	struct scsi_device *sdev = to_scsi_device(dev);
	enum scsi_device_state state = 0;

725
	for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
L
Linus Torvalds 已提交
726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
		const int len = strlen(sdev_states[i].name);
		if (strncmp(sdev_states[i].name, buf, len) == 0 &&
		   buf[len] == '\n') {
			state = sdev_states[i].value;
			break;
		}
	}
	if (!state)
		return -EINVAL;

	if (scsi_device_set_state(sdev, state))
		return -EINVAL;
	return count;
}

static ssize_t
742
show_state_field(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
743 744 745 746 747 748 749 750 751 752 753 754 755
{
	struct scsi_device *sdev = to_scsi_device(dev);
	const char *name = scsi_device_state_name(sdev->sdev_state);

	if (!name)
		return -EINVAL;

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

static DEVICE_ATTR(state, S_IRUGO | S_IWUSR, show_state_field, store_state_field);

static ssize_t
756 757
show_queue_type_field(struct device *dev, struct device_attribute *attr,
		      char *buf)
L
Linus Torvalds 已提交
758 759 760 761
{
	struct scsi_device *sdev = to_scsi_device(dev);
	const char *name = "none";

762
	if (sdev->simple_tags)
L
Linus Torvalds 已提交
763 764 765 766 767
		name = "simple";

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

768 769 770 771 772 773
static ssize_t
store_queue_type_field(struct device *dev, struct device_attribute *attr,
		       const char *buf, size_t count)
{
	struct scsi_device *sdev = to_scsi_device(dev);

774
	if (!sdev->tagged_supported)
775
		return -EINVAL;
776 777 778
		
	sdev_printk(KERN_INFO, sdev,
		    "ignoring write to deprecated queue_type attribute");
779 780 781 782 783
	return count;
}

static DEVICE_ATTR(queue_type, S_IRUGO | S_IWUSR, show_queue_type_field,
		   store_queue_type_field);
L
Linus Torvalds 已提交
784

785 786 787 788 789 790 791 792
#define sdev_vpd_pg_attr(_page)						\
static ssize_t							\
show_vpd_##_page(struct file *filp, struct kobject *kobj,	\
		 struct bin_attribute *bin_attr,			\
		 char *buf, loff_t off, size_t count)			\
{									\
	struct device *dev = container_of(kobj, struct device, kobj);	\
	struct scsi_device *sdev = to_scsi_device(dev);			\
H
Hannes Reinecke 已提交
793
	int ret;							\
794 795
	if (!sdev->vpd_##_page)						\
		return -EINVAL;						\
H
Hannes Reinecke 已提交
796 797 798
	rcu_read_lock();						\
	ret = memory_read_from_buffer(buf, count, &off,			\
				      rcu_dereference(sdev->vpd_##_page), \
799
				       sdev->vpd_##_page##_len);	\
H
Hannes Reinecke 已提交
800 801
	rcu_read_unlock();						\
	return ret;						\
802 803 804 805 806 807 808 809 810
}									\
static struct bin_attribute dev_attr_vpd_##_page = {		\
	.attr =	{.name = __stringify(vpd_##_page), .mode = S_IRUGO },	\
	.size = 0,							\
	.read = show_vpd_##_page,					\
};

sdev_vpd_pg_attr(pg83);
sdev_vpd_pg_attr(pg80);
L
Linus Torvalds 已提交
811

812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
static ssize_t show_inquiry(struct file *filep, struct kobject *kobj,
			    struct bin_attribute *bin_attr,
			    char *buf, loff_t off, size_t count)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct scsi_device *sdev = to_scsi_device(dev);

	if (!sdev->inquiry)
		return -EINVAL;

	return memory_read_from_buffer(buf, count, &off, sdev->inquiry,
				       sdev->inquiry_len);
}

static struct bin_attribute dev_attr_inquiry = {
	.attr = {
		.name = "inquiry",
		.mode = S_IRUGO,
	},
	.size = 0,
	.read = show_inquiry,
};

L
Linus Torvalds 已提交
835
static ssize_t
836 837
show_iostat_counterbits(struct device *dev, struct device_attribute *attr,
			char *buf)
L
Linus Torvalds 已提交
838 839 840 841 842 843 844 845
{
	return snprintf(buf, 20, "%d\n", (int)sizeof(atomic_t) * 8);
}

static DEVICE_ATTR(iocounterbits, S_IRUGO, show_iostat_counterbits, NULL);

#define show_sdev_iostat(field)						\
static ssize_t								\
846 847
show_iostat_##field(struct device *dev, struct device_attribute *attr,	\
		    char *buf)						\
L
Linus Torvalds 已提交
848 849 850 851 852 853 854 855 856 857 858
{									\
	struct scsi_device *sdev = to_scsi_device(dev);			\
	unsigned long long count = atomic_read(&sdev->field);		\
	return snprintf(buf, 20, "0x%llx\n", count);			\
}									\
static DEVICE_ATTR(field, S_IRUGO, show_iostat_##field, NULL)

show_sdev_iostat(iorequest_cnt);
show_sdev_iostat(iodone_cnt);
show_sdev_iostat(ioerr_cnt);

859 860 861 862 863 864 865 866
static ssize_t
sdev_show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct scsi_device *sdev;
	sdev = to_scsi_device(dev);
	return snprintf (buf, 20, SCSI_DEVICE_MODALIAS_FMT "\n", sdev->type);
}
static DEVICE_ATTR(modalias, S_IRUGO, sdev_show_modalias, NULL);
L
Linus Torvalds 已提交
867

868 869 870
#define DECLARE_EVT_SHOW(name, Cap_name)				\
static ssize_t								\
sdev_show_evt_##name(struct device *dev, struct device_attribute *attr,	\
871
		     char *buf)						\
872 873 874 875 876 877 878 879
{									\
	struct scsi_device *sdev = to_scsi_device(dev);			\
	int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\
	return snprintf(buf, 20, "%d\n", val);				\
}

#define DECLARE_EVT_STORE(name, Cap_name)				\
static ssize_t								\
880
sdev_store_evt_##name(struct device *dev, struct device_attribute *attr,\
881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901
		      const char *buf, size_t count)			\
{									\
	struct scsi_device *sdev = to_scsi_device(dev);			\
	int val = simple_strtoul(buf, NULL, 0);				\
	if (val == 0)							\
		clear_bit(SDEV_EVT_##Cap_name, sdev->supported_events);	\
	else if (val == 1)						\
		set_bit(SDEV_EVT_##Cap_name, sdev->supported_events);	\
	else								\
		return -EINVAL;						\
	return count;							\
}

#define DECLARE_EVT(name, Cap_name)					\
	DECLARE_EVT_SHOW(name, Cap_name)				\
	DECLARE_EVT_STORE(name, Cap_name)				\
	static DEVICE_ATTR(evt_##name, S_IRUGO, sdev_show_evt_##name,	\
			   sdev_store_evt_##name);
#define REF_EVT(name) &dev_attr_evt_##name.attr

DECLARE_EVT(media_change, MEDIA_CHANGE)
902 903 904 905 906
DECLARE_EVT(inquiry_change_reported, INQUIRY_CHANGE_REPORTED)
DECLARE_EVT(capacity_change_reported, CAPACITY_CHANGE_REPORTED)
DECLARE_EVT(soft_threshold_reached, SOFT_THRESHOLD_REACHED_REPORTED)
DECLARE_EVT(mode_parameter_change_reported, MODE_PARAMETER_CHANGE_REPORTED)
DECLARE_EVT(lun_change_reported, LUN_CHANGE_REPORTED)
907

908
static ssize_t
909 910
sdev_store_queue_depth(struct device *dev, struct device_attribute *attr,
		       const char *buf, size_t count)
L
Linus Torvalds 已提交
911 912 913 914 915 916 917 918 919 920
{
	int depth, retval;
	struct scsi_device *sdev = to_scsi_device(dev);
	struct scsi_host_template *sht = sdev->host->hostt;

	if (!sht->change_queue_depth)
		return -EINVAL;

	depth = simple_strtoul(buf, NULL, 0);

921
	if (depth < 1 || depth > sdev->host->can_queue)
L
Linus Torvalds 已提交
922 923
		return -EINVAL;

924
	retval = sht->change_queue_depth(sdev, depth);
L
Linus Torvalds 已提交
925 926 927
	if (retval < 0)
		return retval;

V
Vasu Dev 已提交
928 929
	sdev->max_queue_depth = sdev->queue_depth;

L
Linus Torvalds 已提交
930 931
	return count;
}
932
sdev_show_function(queue_depth, "%d\n");
L
Linus Torvalds 已提交
933

934 935
static DEVICE_ATTR(queue_depth, S_IRUGO | S_IWUSR, sdev_show_queue_depth,
		   sdev_store_queue_depth);
L
Linus Torvalds 已提交
936

H
Hannes Reinecke 已提交
937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952
static ssize_t
sdev_show_wwid(struct device *dev, struct device_attribute *attr,
		    char *buf)
{
	struct scsi_device *sdev = to_scsi_device(dev);
	ssize_t count;

	count = scsi_vpd_lun_id(sdev, buf, PAGE_SIZE);
	if (count > 0) {
		buf[count] = '\n';
		count++;
	}
	return count;
}
static DEVICE_ATTR(wwid, S_IRUGO, sdev_show_wwid, NULL);

953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004
#ifdef CONFIG_SCSI_DH
static ssize_t
sdev_show_dh_state(struct device *dev, struct device_attribute *attr,
		   char *buf)
{
	struct scsi_device *sdev = to_scsi_device(dev);

	if (!sdev->handler)
		return snprintf(buf, 20, "detached\n");

	return snprintf(buf, 20, "%s\n", sdev->handler->name);
}

static ssize_t
sdev_store_dh_state(struct device *dev, struct device_attribute *attr,
		    const char *buf, size_t count)
{
	struct scsi_device *sdev = to_scsi_device(dev);
	int err = -EINVAL;

	if (sdev->sdev_state == SDEV_CANCEL ||
	    sdev->sdev_state == SDEV_DEL)
		return -ENODEV;

	if (!sdev->handler) {
		/*
		 * Attach to a device handler
		 */
		err = scsi_dh_attach(sdev->request_queue, buf);
	} else if (!strncmp(buf, "activate", 8)) {
		/*
		 * Activate a device handler
		 */
		if (sdev->handler->activate)
			err = sdev->handler->activate(sdev, NULL, NULL);
		else
			err = 0;
	} else if (!strncmp(buf, "detach", 6)) {
		/*
		 * Detach from a device handler
		 */
		sdev_printk(KERN_WARNING, sdev,
			    "can't detach handler %s.\n",
			    sdev->handler->name);
		err = -EINVAL;
	}

	return err < 0 ? err : count;
}

static DEVICE_ATTR(dh_state, S_IRUGO | S_IWUSR, sdev_show_dh_state,
		   sdev_store_dh_state);
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041

static ssize_t
sdev_show_access_state(struct device *dev,
		       struct device_attribute *attr,
		       char *buf)
{
	struct scsi_device *sdev = to_scsi_device(dev);
	unsigned char access_state;
	const char *access_state_name;

	if (!sdev->handler)
		return -EINVAL;

	access_state = (sdev->access_state & SCSI_ACCESS_STATE_MASK);
	access_state_name = scsi_access_state_name(access_state);

	return sprintf(buf, "%s\n",
		       access_state_name ? access_state_name : "unknown");
}
static DEVICE_ATTR(access_state, S_IRUGO, sdev_show_access_state, NULL);

static ssize_t
sdev_show_preferred_path(struct device *dev,
			 struct device_attribute *attr,
			 char *buf)
{
	struct scsi_device *sdev = to_scsi_device(dev);

	if (!sdev->handler)
		return -EINVAL;

	if (sdev->access_state & SCSI_ACCESS_STATE_PREFERRED)
		return sprintf(buf, "1\n");
	else
		return sprintf(buf, "0\n");
}
static DEVICE_ATTR(preferred_path, S_IRUGO, sdev_show_preferred_path, NULL);
1042 1043
#endif

V
Vasu Dev 已提交
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
static ssize_t
sdev_show_queue_ramp_up_period(struct device *dev,
			       struct device_attribute *attr,
			       char *buf)
{
	struct scsi_device *sdev;
	sdev = to_scsi_device(dev);
	return snprintf(buf, 20, "%u\n",
			jiffies_to_msecs(sdev->queue_ramp_up_period));
}

static ssize_t
sdev_store_queue_ramp_up_period(struct device *dev,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
	struct scsi_device *sdev = to_scsi_device(dev);
1061
	unsigned int period;
V
Vasu Dev 已提交
1062

1063
	if (kstrtouint(buf, 10, &period))
V
Vasu Dev 已提交
1064 1065 1066
		return -EINVAL;

	sdev->queue_ramp_up_period = msecs_to_jiffies(period);
1067
	return count;
V
Vasu Dev 已提交
1068 1069
}

1070 1071 1072
static DEVICE_ATTR(queue_ramp_up_period, S_IRUGO | S_IWUSR,
		   sdev_show_queue_ramp_up_period,
		   sdev_store_queue_ramp_up_period);
V
Vasu Dev 已提交
1073

1074 1075
static umode_t scsi_sdev_attr_is_visible(struct kobject *kobj,
					 struct attribute *attr, int i)
L
Linus Torvalds 已提交
1076
{
1077
	struct device *dev = container_of(kobj, struct device, kobj);
L
Linus Torvalds 已提交
1078 1079 1080
	struct scsi_device *sdev = to_scsi_device(dev);


1081 1082 1083
	if (attr == &dev_attr_queue_depth.attr &&
	    !sdev->host->hostt->change_queue_depth)
		return S_IRUGO;
L
Linus Torvalds 已提交
1084

1085 1086 1087
	if (attr == &dev_attr_queue_ramp_up_period.attr &&
	    !sdev->host->hostt->change_queue_depth)
		return 0;
L
Linus Torvalds 已提交
1088

1089 1090 1091 1092 1093 1094 1095 1096
#ifdef CONFIG_SCSI_DH
	if (attr == &dev_attr_access_state.attr &&
	    !sdev->handler)
		return 0;
	if (attr == &dev_attr_preferred_path.attr &&
	    !sdev->handler)
		return 0;
#endif
1097
	return attr->mode;
L
Linus Torvalds 已提交
1098 1099
}

1100 1101 1102 1103 1104 1105 1106 1107 1108 1109
static umode_t scsi_sdev_bin_attr_is_visible(struct kobject *kobj,
					     struct bin_attribute *attr, int i)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct scsi_device *sdev = to_scsi_device(dev);


	if (attr == &dev_attr_vpd_pg80 && !sdev->vpd_pg80)
		return 0;

1110
	if (attr == &dev_attr_vpd_pg83 && !sdev->vpd_pg83)
1111 1112 1113 1114 1115
		return 0;

	return S_IRUGO;
}

1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136
/* Default template for device attributes.  May NOT be modified */
static struct attribute *scsi_sdev_attrs[] = {
	&dev_attr_device_blocked.attr,
	&dev_attr_type.attr,
	&dev_attr_scsi_level.attr,
	&dev_attr_device_busy.attr,
	&dev_attr_vendor.attr,
	&dev_attr_model.attr,
	&dev_attr_rev.attr,
	&dev_attr_rescan.attr,
	&dev_attr_delete.attr,
	&dev_attr_state.attr,
	&dev_attr_timeout.attr,
	&dev_attr_eh_timeout.attr,
	&dev_attr_iocounterbits.attr,
	&dev_attr_iorequest_cnt.attr,
	&dev_attr_iodone_cnt.attr,
	&dev_attr_ioerr_cnt.attr,
	&dev_attr_modalias.attr,
	&dev_attr_queue_depth.attr,
	&dev_attr_queue_type.attr,
H
Hannes Reinecke 已提交
1137
	&dev_attr_wwid.attr,
1138 1139
#ifdef CONFIG_SCSI_DH
	&dev_attr_dh_state.attr,
1140 1141
	&dev_attr_access_state.attr,
	&dev_attr_preferred_path.attr,
1142
#endif
1143 1144 1145 1146 1147 1148 1149 1150 1151 1152
	&dev_attr_queue_ramp_up_period.attr,
	REF_EVT(media_change),
	REF_EVT(inquiry_change_reported),
	REF_EVT(capacity_change_reported),
	REF_EVT(soft_threshold_reached),
	REF_EVT(mode_parameter_change_reported),
	REF_EVT(lun_change_reported),
	NULL
};

1153 1154 1155
static struct bin_attribute *scsi_sdev_bin_attrs[] = {
	&dev_attr_vpd_pg83,
	&dev_attr_vpd_pg80,
1156
	&dev_attr_inquiry,
1157 1158
	NULL
};
1159 1160
static struct attribute_group scsi_sdev_attr_group = {
	.attrs =	scsi_sdev_attrs,
1161
	.bin_attrs =	scsi_sdev_bin_attrs,
1162
	.is_visible =	scsi_sdev_attr_is_visible,
1163
	.is_bin_visible = scsi_sdev_bin_attr_is_visible,
1164 1165 1166 1167 1168 1169 1170
};

static const struct attribute_group *scsi_sdev_attr_groups[] = {
	&scsi_sdev_attr_group,
	NULL
};

1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
static int scsi_target_add(struct scsi_target *starget)
{
	int error;

	if (starget->state != STARGET_CREATED)
		return 0;

	error = device_add(&starget->dev);
	if (error) {
		dev_err(&starget->dev, "target device_add failed, error %d\n", error);
		return error;
	}
	transport_add_device(&starget->dev);
	starget->state = STARGET_RUNNING;

1186 1187 1188 1189
	pm_runtime_set_active(&starget->dev);
	pm_runtime_enable(&starget->dev);
	device_enable_async_suspend(&starget->dev);

1190 1191 1192
	return 0;
}

L
Linus Torvalds 已提交
1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
/**
 * scsi_sysfs_add_sdev - add scsi device to sysfs
 * @sdev:	scsi_device to add
 *
 * Return value:
 * 	0 on Success / non-zero on Failure
 **/
int scsi_sysfs_add_sdev(struct scsi_device *sdev)
{
	int error, i;
1203
	struct request_queue *rq = sdev->request_queue;
1204
	struct scsi_target *starget = sdev->sdev_target;
L
Linus Torvalds 已提交
1205

1206 1207
	error = scsi_device_set_state(sdev, SDEV_RUNNING);
	if (error)
L
Linus Torvalds 已提交
1208 1209
		return error;

1210 1211 1212 1213 1214
	error = scsi_target_add(starget);
	if (error)
		return error;

	transport_configure_device(&starget->dev);
1215

1216
	device_enable_async_suspend(&sdev->sdev_gendev);
1217 1218 1219 1220 1221 1222 1223 1224
	scsi_autopm_get_target(starget);
	pm_runtime_set_active(&sdev->sdev_gendev);
	pm_runtime_forbid(&sdev->sdev_gendev);
	pm_runtime_enable(&sdev->sdev_gendev);
	scsi_autopm_put_target(starget);

	scsi_autopm_get_device(sdev);

1225
	error = scsi_dh_add_device(sdev);
1226 1227 1228 1229
	if (error)
		/*
		 * device_handler is optional, so any error can be ignored
		 */
1230 1231 1232
		sdev_printk(KERN_INFO, sdev,
				"failed to add device handler: %d\n", error);

1233 1234 1235 1236 1237 1238 1239 1240
	error = device_add(&sdev->sdev_gendev);
	if (error) {
		sdev_printk(KERN_INFO, sdev,
				"failed to add device: %d\n", error);
		scsi_dh_remove_device(sdev);
		return error;
	}

1241
	device_enable_async_suspend(&sdev->sdev_dev);
1242
	error = device_add(&sdev->sdev_dev);
L
Linus Torvalds 已提交
1243
	if (error) {
A
Alan Stern 已提交
1244 1245
		sdev_printk(KERN_INFO, sdev,
				"failed to add class device: %d\n", error);
1246
		scsi_dh_remove_device(sdev);
1247
		device_del(&sdev->sdev_gendev);
1248
		return error;
L
Linus Torvalds 已提交
1249
	}
1250 1251
	transport_add_device(&sdev->sdev_gendev);
	sdev->is_visible = 1;
L
Linus Torvalds 已提交
1252

1253
	error = bsg_register_queue(rq, &sdev->sdev_gendev, NULL, NULL);
1254 1255

	if (error)
1256 1257
		/* we're treating error on bsg register as non-fatal,
		 * so pretend nothing went wrong */
1258 1259 1260
		sdev_printk(KERN_INFO, sdev,
			    "Failed to register bsg queue, errno=%d\n", error);

1261
	/* add additional host specific attributes */
L
Linus Torvalds 已提交
1262 1263
	if (sdev->host->hostt->sdev_attrs) {
		for (i = 0; sdev->host->hostt->sdev_attrs[i]; i++) {
1264
			error = device_create_file(&sdev->sdev_gendev,
L
Linus Torvalds 已提交
1265
					sdev->host->hostt->sdev_attrs[i]);
1266
			if (error)
1267
				return error;
L
Linus Torvalds 已提交
1268 1269 1270
		}
	}

1271
	scsi_autopm_put_device(sdev);
L
Linus Torvalds 已提交
1272 1273 1274
	return error;
}

1275
void __scsi_remove_device(struct scsi_device *sdev)
L
Linus Torvalds 已提交
1276
{
J
James Bottomley 已提交
1277 1278
	struct device *dev = &sdev->sdev_gendev;

1279 1280 1281 1282 1283 1284 1285 1286
	/*
	 * This cleanup path is not reentrant and while it is impossible
	 * to get a new reference with scsi_device_get() someone can still
	 * hold a previously acquired one.
	 */
	if (sdev->sdev_state == SDEV_DEL)
		return;

1287 1288 1289
	if (sdev->is_visible) {
		if (scsi_device_set_state(sdev, SDEV_CANCEL) != 0)
			return;
L
Linus Torvalds 已提交
1290

1291 1292 1293
		bsg_unregister_queue(sdev->request_queue);
		device_unregister(&sdev->sdev_dev);
		transport_remove_device(dev);
1294
		scsi_dh_remove_device(sdev);
1295 1296 1297
		device_del(dev);
	} else
		put_device(&sdev->sdev_dev);
1298 1299 1300 1301 1302 1303

	/*
	 * Stop accepting new requests and wait until all queuecommand() and
	 * scsi_run_queue() invocations have finished before tearing down the
	 * device.
	 */
L
Linus Torvalds 已提交
1304
	scsi_device_set_state(sdev, SDEV_DEL);
1305 1306 1307
	blk_cleanup_queue(sdev->request_queue);
	cancel_work_sync(&sdev->requeue_work);

L
Linus Torvalds 已提交
1308 1309
	if (sdev->host->hostt->slave_destroy)
		sdev->host->hostt->slave_destroy(sdev);
J
James Bottomley 已提交
1310
	transport_destroy_device(dev);
1311

1312 1313 1314 1315 1316 1317 1318
	/*
	 * Paired with the kref_get() in scsi_sysfs_initialize().  We have
	 * remoed sysfs visibility from the device, so make the target
	 * invisible if this was the last device underneath it.
	 */
	scsi_target_reap(scsi_target(sdev));

J
James Bottomley 已提交
1319
	put_device(dev);
1320 1321 1322 1323 1324 1325 1326 1327
}

/**
 * scsi_remove_device - unregister a device from the scsi bus
 * @sdev:	scsi_device to unregister
 **/
void scsi_remove_device(struct scsi_device *sdev)
{
1328 1329
	struct Scsi_Host *shost = sdev->host;

1330
	mutex_lock(&shost->scan_mutex);
1331
	__scsi_remove_device(sdev);
1332
	mutex_unlock(&shost->scan_mutex);
L
Linus Torvalds 已提交
1333 1334 1335
}
EXPORT_SYMBOL(scsi_remove_device);

A
Adrian Bunk 已提交
1336
static void __scsi_remove_target(struct scsi_target *starget)
L
Linus Torvalds 已提交
1337 1338 1339
{
	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
	unsigned long flags;
1340
	struct scsi_device *sdev;
L
Linus Torvalds 已提交
1341 1342

	spin_lock_irqsave(shost->host_lock, flags);
1343 1344
 restart:
	list_for_each_entry(sdev, &shost->__devices, siblings) {
L
Linus Torvalds 已提交
1345
		if (sdev->channel != starget->channel ||
1346
		    sdev->id != starget->id ||
1347
		    scsi_device_get(sdev))
L
Linus Torvalds 已提交
1348 1349 1350
			continue;
		spin_unlock_irqrestore(shost->host_lock, flags);
		scsi_remove_device(sdev);
1351
		scsi_device_put(sdev);
L
Linus Torvalds 已提交
1352
		spin_lock_irqsave(shost->host_lock, flags);
1353
		goto restart;
L
Linus Torvalds 已提交
1354 1355
	}
	spin_unlock_irqrestore(shost->host_lock, flags);
1356 1357
}

L
Linus Torvalds 已提交
1358 1359 1360 1361 1362 1363 1364 1365 1366 1367
/**
 * scsi_remove_target - try to remove a target and all its devices
 * @dev: generic starget or parent of generic stargets to be removed
 *
 * Note: This is slightly racy.  It is possible that if the user
 * requests the addition of another device then the target won't be
 * removed.
 */
void scsi_remove_target(struct device *dev)
{
1368
	struct Scsi_Host *shost = dev_to_shost(dev->parent);
1369
	struct scsi_target *starget, *last_target = NULL;
1370 1371
	unsigned long flags;

1372
restart:
1373 1374
	spin_lock_irqsave(shost->host_lock, flags);
	list_for_each_entry(starget, &shost->__targets, siblings) {
1375 1376
		if (starget->state == STARGET_DEL ||
		    starget == last_target)
1377 1378
			continue;
		if (starget->dev.parent == dev || &starget->dev == dev) {
1379
			kref_get(&starget->reap_ref);
1380
			last_target = starget;
1381 1382
			spin_unlock_irqrestore(shost->host_lock, flags);
			__scsi_remove_target(starget);
1383 1384
			scsi_target_reap(starget);
			goto restart;
1385
		}
L
Linus Torvalds 已提交
1386
	}
1387
	spin_unlock_irqrestore(shost->host_lock, flags);
L
Linus Torvalds 已提交
1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414
}
EXPORT_SYMBOL(scsi_remove_target);

int scsi_register_driver(struct device_driver *drv)
{
	drv->bus = &scsi_bus_type;

	return driver_register(drv);
}
EXPORT_SYMBOL(scsi_register_driver);

int scsi_register_interface(struct class_interface *intf)
{
	intf->class = &sdev_class;

	return class_interface_register(intf);
}
EXPORT_SYMBOL(scsi_register_interface);

/**
 * scsi_sysfs_add_host - add scsi host to subsystem
 * @shost:     scsi host struct to add to subsystem
 **/
int scsi_sysfs_add_host(struct Scsi_Host *shost)
{
	int error, i;

1415
	/* add host specific attributes */
L
Linus Torvalds 已提交
1416 1417
	if (shost->hostt->shost_attrs) {
		for (i = 0; shost->hostt->shost_attrs[i]; i++) {
1418
			error = device_create_file(&shost->shost_dev,
1419
					shost->hostt->shost_attrs[i]);
L
Linus Torvalds 已提交
1420 1421 1422 1423 1424 1425
			if (error)
				return error;
		}
	}

	transport_register_device(&shost->shost_gendev);
1426
	transport_configure_device(&shost->shost_gendev);
L
Linus Torvalds 已提交
1427 1428 1429
	return 0;
}

1430 1431 1432 1433 1434 1435
static struct device_type scsi_dev_type = {
	.name =		"scsi_device",
	.release =	scsi_device_dev_release,
	.groups =	scsi_sdev_attr_groups,
};

L
Linus Torvalds 已提交
1436 1437 1438 1439 1440 1441 1442 1443
void scsi_sysfs_device_initialize(struct scsi_device *sdev)
{
	unsigned long flags;
	struct Scsi_Host *shost = sdev->host;
	struct scsi_target  *starget = sdev->sdev_target;

	device_initialize(&sdev->sdev_gendev);
	sdev->sdev_gendev.bus = &scsi_bus_type;
1444
	sdev->sdev_gendev.type = &scsi_dev_type;
H
Hannes Reinecke 已提交
1445
	dev_set_name(&sdev->sdev_gendev, "%d:%d:%d:%llu",
1446 1447
		     sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);

1448
	device_initialize(&sdev->sdev_dev);
1449
	sdev->sdev_dev.parent = get_device(&sdev->sdev_gendev);
1450
	sdev->sdev_dev.class = &sdev_class;
H
Hannes Reinecke 已提交
1451
	dev_set_name(&sdev->sdev_dev, "%d:%d:%d:%llu",
1452
		     sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
1453 1454 1455 1456 1457 1458 1459
	/*
	 * Get a default scsi_level from the target (derived from sibling
	 * devices).  This is the best we can do for guessing how to set
	 * sdev->lun_in_cdb for the initial INQUIRY command.  For LUN 0 the
	 * setting doesn't matter, because all the bits are zero anyway.
	 * But it does matter for higher LUNs.
	 */
1460
	sdev->scsi_level = starget->scsi_level;
1461 1462 1463 1464 1465
	if (sdev->scsi_level <= SCSI_2 &&
			sdev->scsi_level != SCSI_UNKNOWN &&
			!shost->no_scsi2_lun_in_cdb)
		sdev->lun_in_cdb = 1;

L
Linus Torvalds 已提交
1466 1467 1468 1469 1470
	transport_setup_device(&sdev->sdev_gendev);
	spin_lock_irqsave(shost->host_lock, flags);
	list_add_tail(&sdev->same_target_siblings, &starget->devices);
	list_add_tail(&sdev->siblings, &shost->__devices);
	spin_unlock_irqrestore(shost->host_lock, flags);
1471 1472 1473 1474 1475 1476
	/*
	 * device can now only be removed via __scsi_remove_device() so hold
	 * the target.  Target will be held in CREATED state until something
	 * beneath it becomes visible (in which case it moves to RUNNING)
	 */
	kref_get(&starget->reap_ref);
L
Linus Torvalds 已提交
1477 1478 1479 1480
}

int scsi_is_sdev_device(const struct device *dev)
{
1481
	return dev->type == &scsi_dev_type;
L
Linus Torvalds 已提交
1482 1483 1484 1485 1486 1487
}
EXPORT_SYMBOL(scsi_is_sdev_device);

/* A blank transport template that is used in drivers that don't
 * yet implement Transport Attributes */
struct scsi_transport_template blank_transport_template = { { { {NULL, }, }, }, };