1 /* 2 * SCSI RDMA (SRP) transport class 3 * 4 * Copyright (C) 2007 FUJITA Tomonori <tomof@acm.org> 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as 8 * published by the Free Software Foundation, version 2 of the 9 * License. 10 * 11 * This program is distributed in the hope that it will be useful, but 12 * WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 19 * 02110-1301 USA 20 */ 21 #include <linux/init.h> 22 #include <linux/module.h> 23 #include <linux/jiffies.h> 24 #include <linux/err.h> 25 #include <linux/slab.h> 26 #include <linux/string.h> 27 #include <linux/delay.h> 28 29 #include <scsi/scsi.h> 30 #include <scsi/scsi_cmnd.h> 31 #include <scsi/scsi_device.h> 32 #include <scsi/scsi_host.h> 33 #include <scsi/scsi_transport.h> 34 #include <scsi/scsi_transport_srp.h> 35 #include "scsi_priv.h" 36 37 struct srp_host_attrs { 38 atomic_t next_port_id; 39 }; 40 #define to_srp_host_attrs(host) ((struct srp_host_attrs *)(host)->shost_data) 41 42 #define SRP_HOST_ATTRS 0 43 #define SRP_RPORT_ATTRS 8 44 45 struct srp_internal { 46 struct scsi_transport_template t; 47 struct srp_function_template *f; 48 49 struct device_attribute *host_attrs[SRP_HOST_ATTRS + 1]; 50 51 struct device_attribute *rport_attrs[SRP_RPORT_ATTRS + 1]; 52 struct transport_container rport_attr_cont; 53 }; 54 55 #define to_srp_internal(tmpl) container_of(tmpl, struct srp_internal, t) 56 57 #define dev_to_rport(d) container_of(d, struct srp_rport, dev) 58 #define transport_class_to_srp_rport(dev) dev_to_rport((dev)->parent) 59 static inline struct Scsi_Host *rport_to_shost(struct srp_rport *r) 60 { 61 return dev_to_shost(r->dev.parent); 62 } 63 64 /** 65 * srp_tmo_valid() - check timeout combination validity 66 * @reconnect_delay: Reconnect delay in seconds. 67 * @fast_io_fail_tmo: Fast I/O fail timeout in seconds. 68 * @dev_loss_tmo: Device loss timeout in seconds. 69 * 70 * The combination of the timeout parameters must be such that SCSI commands 71 * are finished in a reasonable time. Hence do not allow the fast I/O fail 72 * timeout to exceed SCSI_DEVICE_BLOCK_MAX_TIMEOUT nor allow dev_loss_tmo to 73 * exceed that limit if failing I/O fast has been disabled. Furthermore, these 74 * parameters must be such that multipath can detect failed paths timely. 75 * Hence do not allow all three parameters to be disabled simultaneously. 76 */ 77 int srp_tmo_valid(int reconnect_delay, int fast_io_fail_tmo, int dev_loss_tmo) 78 { 79 if (reconnect_delay < 0 && fast_io_fail_tmo < 0 && dev_loss_tmo < 0) 80 return -EINVAL; 81 if (reconnect_delay == 0) 82 return -EINVAL; 83 if (fast_io_fail_tmo > SCSI_DEVICE_BLOCK_MAX_TIMEOUT) 84 return -EINVAL; 85 if (fast_io_fail_tmo < 0 && 86 dev_loss_tmo > SCSI_DEVICE_BLOCK_MAX_TIMEOUT) 87 return -EINVAL; 88 if (dev_loss_tmo >= LONG_MAX / HZ) 89 return -EINVAL; 90 if (fast_io_fail_tmo >= 0 && dev_loss_tmo >= 0 && 91 fast_io_fail_tmo >= dev_loss_tmo) 92 return -EINVAL; 93 return 0; 94 } 95 EXPORT_SYMBOL_GPL(srp_tmo_valid); 96 97 static int srp_host_setup(struct transport_container *tc, struct device *dev, 98 struct device *cdev) 99 { 100 struct Scsi_Host *shost = dev_to_shost(dev); 101 struct srp_host_attrs *srp_host = to_srp_host_attrs(shost); 102 103 atomic_set(&srp_host->next_port_id, 0); 104 return 0; 105 } 106 107 static DECLARE_TRANSPORT_CLASS(srp_host_class, "srp_host", srp_host_setup, 108 NULL, NULL); 109 110 static DECLARE_TRANSPORT_CLASS(srp_rport_class, "srp_remote_ports", 111 NULL, NULL, NULL); 112 113 #define SRP_PID(p) \ 114 (p)->port_id[0], (p)->port_id[1], (p)->port_id[2], (p)->port_id[3], \ 115 (p)->port_id[4], (p)->port_id[5], (p)->port_id[6], (p)->port_id[7], \ 116 (p)->port_id[8], (p)->port_id[9], (p)->port_id[10], (p)->port_id[11], \ 117 (p)->port_id[12], (p)->port_id[13], (p)->port_id[14], (p)->port_id[15] 118 119 #define SRP_PID_FMT "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:" \ 120 "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x" 121 122 static ssize_t 123 show_srp_rport_id(struct device *dev, struct device_attribute *attr, 124 char *buf) 125 { 126 struct srp_rport *rport = transport_class_to_srp_rport(dev); 127 return sprintf(buf, SRP_PID_FMT "\n", SRP_PID(rport)); 128 } 129 130 static DEVICE_ATTR(port_id, S_IRUGO, show_srp_rport_id, NULL); 131 132 static const struct { 133 u32 value; 134 char *name; 135 } srp_rport_role_names[] = { 136 {SRP_RPORT_ROLE_INITIATOR, "SRP Initiator"}, 137 {SRP_RPORT_ROLE_TARGET, "SRP Target"}, 138 }; 139 140 static ssize_t 141 show_srp_rport_roles(struct device *dev, struct device_attribute *attr, 142 char *buf) 143 { 144 struct srp_rport *rport = transport_class_to_srp_rport(dev); 145 int i; 146 char *name = NULL; 147 148 for (i = 0; i < ARRAY_SIZE(srp_rport_role_names); i++) 149 if (srp_rport_role_names[i].value == rport->roles) { 150 name = srp_rport_role_names[i].name; 151 break; 152 } 153 return sprintf(buf, "%s\n", name ? : "unknown"); 154 } 155 156 static DEVICE_ATTR(roles, S_IRUGO, show_srp_rport_roles, NULL); 157 158 static ssize_t store_srp_rport_delete(struct device *dev, 159 struct device_attribute *attr, 160 const char *buf, size_t count) 161 { 162 struct srp_rport *rport = transport_class_to_srp_rport(dev); 163 struct Scsi_Host *shost = dev_to_shost(dev); 164 struct srp_internal *i = to_srp_internal(shost->transportt); 165 166 if (i->f->rport_delete) { 167 i->f->rport_delete(rport); 168 return count; 169 } else { 170 return -ENOSYS; 171 } 172 } 173 174 static DEVICE_ATTR(delete, S_IWUSR, NULL, store_srp_rport_delete); 175 176 static ssize_t show_srp_rport_state(struct device *dev, 177 struct device_attribute *attr, 178 char *buf) 179 { 180 static const char *const state_name[] = { 181 [SRP_RPORT_RUNNING] = "running", 182 [SRP_RPORT_BLOCKED] = "blocked", 183 [SRP_RPORT_FAIL_FAST] = "fail-fast", 184 [SRP_RPORT_LOST] = "lost", 185 }; 186 struct srp_rport *rport = transport_class_to_srp_rport(dev); 187 enum srp_rport_state state = rport->state; 188 189 return sprintf(buf, "%s\n", 190 (unsigned)state < ARRAY_SIZE(state_name) ? 191 state_name[state] : "???"); 192 } 193 194 static DEVICE_ATTR(state, S_IRUGO, show_srp_rport_state, NULL); 195 196 static ssize_t srp_show_tmo(char *buf, int tmo) 197 { 198 return tmo >= 0 ? sprintf(buf, "%d\n", tmo) : sprintf(buf, "off\n"); 199 } 200 201 static int srp_parse_tmo(int *tmo, const char *buf) 202 { 203 int res = 0; 204 205 if (strncmp(buf, "off", 3) != 0) 206 res = kstrtoint(buf, 0, tmo); 207 else 208 *tmo = -1; 209 210 return res; 211 } 212 213 static ssize_t show_reconnect_delay(struct device *dev, 214 struct device_attribute *attr, char *buf) 215 { 216 struct srp_rport *rport = transport_class_to_srp_rport(dev); 217 218 return srp_show_tmo(buf, rport->reconnect_delay); 219 } 220 221 static ssize_t store_reconnect_delay(struct device *dev, 222 struct device_attribute *attr, 223 const char *buf, const size_t count) 224 { 225 struct srp_rport *rport = transport_class_to_srp_rport(dev); 226 int res, delay; 227 228 res = srp_parse_tmo(&delay, buf); 229 if (res) 230 goto out; 231 res = srp_tmo_valid(delay, rport->fast_io_fail_tmo, 232 rport->dev_loss_tmo); 233 if (res) 234 goto out; 235 236 if (rport->reconnect_delay <= 0 && delay > 0 && 237 rport->state != SRP_RPORT_RUNNING) { 238 queue_delayed_work(system_long_wq, &rport->reconnect_work, 239 delay * HZ); 240 } else if (delay <= 0) { 241 cancel_delayed_work(&rport->reconnect_work); 242 } 243 rport->reconnect_delay = delay; 244 res = count; 245 246 out: 247 return res; 248 } 249 250 static DEVICE_ATTR(reconnect_delay, S_IRUGO | S_IWUSR, show_reconnect_delay, 251 store_reconnect_delay); 252 253 static ssize_t show_failed_reconnects(struct device *dev, 254 struct device_attribute *attr, char *buf) 255 { 256 struct srp_rport *rport = transport_class_to_srp_rport(dev); 257 258 return sprintf(buf, "%d\n", rport->failed_reconnects); 259 } 260 261 static DEVICE_ATTR(failed_reconnects, S_IRUGO, show_failed_reconnects, NULL); 262 263 static ssize_t show_srp_rport_fast_io_fail_tmo(struct device *dev, 264 struct device_attribute *attr, 265 char *buf) 266 { 267 struct srp_rport *rport = transport_class_to_srp_rport(dev); 268 269 return srp_show_tmo(buf, rport->fast_io_fail_tmo); 270 } 271 272 static ssize_t store_srp_rport_fast_io_fail_tmo(struct device *dev, 273 struct device_attribute *attr, 274 const char *buf, size_t count) 275 { 276 struct srp_rport *rport = transport_class_to_srp_rport(dev); 277 int res; 278 int fast_io_fail_tmo; 279 280 res = srp_parse_tmo(&fast_io_fail_tmo, buf); 281 if (res) 282 goto out; 283 res = srp_tmo_valid(rport->reconnect_delay, fast_io_fail_tmo, 284 rport->dev_loss_tmo); 285 if (res) 286 goto out; 287 rport->fast_io_fail_tmo = fast_io_fail_tmo; 288 res = count; 289 290 out: 291 return res; 292 } 293 294 static DEVICE_ATTR(fast_io_fail_tmo, S_IRUGO | S_IWUSR, 295 show_srp_rport_fast_io_fail_tmo, 296 store_srp_rport_fast_io_fail_tmo); 297 298 static ssize_t show_srp_rport_dev_loss_tmo(struct device *dev, 299 struct device_attribute *attr, 300 char *buf) 301 { 302 struct srp_rport *rport = transport_class_to_srp_rport(dev); 303 304 return srp_show_tmo(buf, rport->dev_loss_tmo); 305 } 306 307 static ssize_t store_srp_rport_dev_loss_tmo(struct device *dev, 308 struct device_attribute *attr, 309 const char *buf, size_t count) 310 { 311 struct srp_rport *rport = transport_class_to_srp_rport(dev); 312 int res; 313 int dev_loss_tmo; 314 315 res = srp_parse_tmo(&dev_loss_tmo, buf); 316 if (res) 317 goto out; 318 res = srp_tmo_valid(rport->reconnect_delay, rport->fast_io_fail_tmo, 319 dev_loss_tmo); 320 if (res) 321 goto out; 322 rport->dev_loss_tmo = dev_loss_tmo; 323 res = count; 324 325 out: 326 return res; 327 } 328 329 static DEVICE_ATTR(dev_loss_tmo, S_IRUGO | S_IWUSR, 330 show_srp_rport_dev_loss_tmo, 331 store_srp_rport_dev_loss_tmo); 332 333 static int srp_rport_set_state(struct srp_rport *rport, 334 enum srp_rport_state new_state) 335 { 336 enum srp_rport_state old_state = rport->state; 337 338 lockdep_assert_held(&rport->mutex); 339 340 switch (new_state) { 341 case SRP_RPORT_RUNNING: 342 switch (old_state) { 343 case SRP_RPORT_LOST: 344 goto invalid; 345 default: 346 break; 347 } 348 break; 349 case SRP_RPORT_BLOCKED: 350 switch (old_state) { 351 case SRP_RPORT_RUNNING: 352 break; 353 default: 354 goto invalid; 355 } 356 break; 357 case SRP_RPORT_FAIL_FAST: 358 switch (old_state) { 359 case SRP_RPORT_LOST: 360 goto invalid; 361 default: 362 break; 363 } 364 break; 365 case SRP_RPORT_LOST: 366 break; 367 } 368 rport->state = new_state; 369 return 0; 370 371 invalid: 372 return -EINVAL; 373 } 374 375 /** 376 * srp_reconnect_work() - reconnect and schedule a new attempt if necessary 377 * @work: Work structure used for scheduling this operation. 378 */ 379 static void srp_reconnect_work(struct work_struct *work) 380 { 381 struct srp_rport *rport = container_of(to_delayed_work(work), 382 struct srp_rport, reconnect_work); 383 struct Scsi_Host *shost = rport_to_shost(rport); 384 int delay, res; 385 386 res = srp_reconnect_rport(rport); 387 if (res != 0) { 388 shost_printk(KERN_ERR, shost, 389 "reconnect attempt %d failed (%d)\n", 390 ++rport->failed_reconnects, res); 391 delay = rport->reconnect_delay * 392 min(100, max(1, rport->failed_reconnects - 10)); 393 if (delay > 0) 394 queue_delayed_work(system_long_wq, 395 &rport->reconnect_work, delay * HZ); 396 } 397 } 398 399 static void __rport_fail_io_fast(struct srp_rport *rport) 400 { 401 struct Scsi_Host *shost = rport_to_shost(rport); 402 struct srp_internal *i; 403 404 lockdep_assert_held(&rport->mutex); 405 406 if (srp_rport_set_state(rport, SRP_RPORT_FAIL_FAST)) 407 return; 408 scsi_target_unblock(rport->dev.parent, SDEV_TRANSPORT_OFFLINE); 409 410 /* Involve the LLD if possible to terminate all I/O on the rport. */ 411 i = to_srp_internal(shost->transportt); 412 if (i->f->terminate_rport_io) 413 i->f->terminate_rport_io(rport); 414 } 415 416 /** 417 * rport_fast_io_fail_timedout() - fast I/O failure timeout handler 418 * @work: Work structure used for scheduling this operation. 419 */ 420 static void rport_fast_io_fail_timedout(struct work_struct *work) 421 { 422 struct srp_rport *rport = container_of(to_delayed_work(work), 423 struct srp_rport, fast_io_fail_work); 424 struct Scsi_Host *shost = rport_to_shost(rport); 425 426 pr_info("fast_io_fail_tmo expired for SRP %s / %s.\n", 427 dev_name(&rport->dev), dev_name(&shost->shost_gendev)); 428 429 mutex_lock(&rport->mutex); 430 if (rport->state == SRP_RPORT_BLOCKED) 431 __rport_fail_io_fast(rport); 432 mutex_unlock(&rport->mutex); 433 } 434 435 /** 436 * rport_dev_loss_timedout() - device loss timeout handler 437 * @work: Work structure used for scheduling this operation. 438 */ 439 static void rport_dev_loss_timedout(struct work_struct *work) 440 { 441 struct srp_rport *rport = container_of(to_delayed_work(work), 442 struct srp_rport, dev_loss_work); 443 struct Scsi_Host *shost = rport_to_shost(rport); 444 struct srp_internal *i = to_srp_internal(shost->transportt); 445 446 pr_info("dev_loss_tmo expired for SRP %s / %s.\n", 447 dev_name(&rport->dev), dev_name(&shost->shost_gendev)); 448 449 mutex_lock(&rport->mutex); 450 WARN_ON(srp_rport_set_state(rport, SRP_RPORT_LOST) != 0); 451 scsi_target_unblock(rport->dev.parent, SDEV_TRANSPORT_OFFLINE); 452 mutex_unlock(&rport->mutex); 453 454 i->f->rport_delete(rport); 455 } 456 457 static void __srp_start_tl_fail_timers(struct srp_rport *rport) 458 { 459 struct Scsi_Host *shost = rport_to_shost(rport); 460 int delay, fast_io_fail_tmo, dev_loss_tmo; 461 462 lockdep_assert_held(&rport->mutex); 463 464 delay = rport->reconnect_delay; 465 fast_io_fail_tmo = rport->fast_io_fail_tmo; 466 dev_loss_tmo = rport->dev_loss_tmo; 467 pr_debug("%s current state: %d\n", dev_name(&shost->shost_gendev), 468 rport->state); 469 470 if (rport->state == SRP_RPORT_LOST) 471 return; 472 if (delay > 0) 473 queue_delayed_work(system_long_wq, &rport->reconnect_work, 474 1UL * delay * HZ); 475 if ((fast_io_fail_tmo >= 0 || dev_loss_tmo >= 0) && 476 srp_rport_set_state(rport, SRP_RPORT_BLOCKED) == 0) { 477 pr_debug("%s new state: %d\n", dev_name(&shost->shost_gendev), 478 rport->state); 479 scsi_target_block(&shost->shost_gendev); 480 if (fast_io_fail_tmo >= 0) 481 queue_delayed_work(system_long_wq, 482 &rport->fast_io_fail_work, 483 1UL * fast_io_fail_tmo * HZ); 484 if (dev_loss_tmo >= 0) 485 queue_delayed_work(system_long_wq, 486 &rport->dev_loss_work, 487 1UL * dev_loss_tmo * HZ); 488 } 489 } 490 491 /** 492 * srp_start_tl_fail_timers() - start the transport layer failure timers 493 * @rport: SRP target port. 494 * 495 * Start the transport layer fast I/O failure and device loss timers. Do not 496 * modify a timer that was already started. 497 */ 498 void srp_start_tl_fail_timers(struct srp_rport *rport) 499 { 500 mutex_lock(&rport->mutex); 501 __srp_start_tl_fail_timers(rport); 502 mutex_unlock(&rport->mutex); 503 } 504 EXPORT_SYMBOL(srp_start_tl_fail_timers); 505 506 /** 507 * scsi_request_fn_active() - number of kernel threads inside scsi_request_fn() 508 * @shost: SCSI host for which to count the number of scsi_request_fn() callers. 509 */ 510 static int scsi_request_fn_active(struct Scsi_Host *shost) 511 { 512 struct scsi_device *sdev; 513 struct request_queue *q; 514 int request_fn_active = 0; 515 516 shost_for_each_device(sdev, shost) { 517 q = sdev->request_queue; 518 519 spin_lock_irq(q->queue_lock); 520 request_fn_active += q->request_fn_active; 521 spin_unlock_irq(q->queue_lock); 522 } 523 524 return request_fn_active; 525 } 526 527 /** 528 * srp_reconnect_rport() - reconnect to an SRP target port 529 * @rport: SRP target port. 530 * 531 * Blocks SCSI command queueing before invoking reconnect() such that 532 * queuecommand() won't be invoked concurrently with reconnect() from outside 533 * the SCSI EH. This is important since a reconnect() implementation may 534 * reallocate resources needed by queuecommand(). 535 * 536 * Notes: 537 * - This function neither waits until outstanding requests have finished nor 538 * tries to abort these. It is the responsibility of the reconnect() 539 * function to finish outstanding commands before reconnecting to the target 540 * port. 541 * - It is the responsibility of the caller to ensure that the resources 542 * reallocated by the reconnect() function won't be used while this function 543 * is in progress. One possible strategy is to invoke this function from 544 * the context of the SCSI EH thread only. Another possible strategy is to 545 * lock the rport mutex inside each SCSI LLD callback that can be invoked by 546 * the SCSI EH (the scsi_host_template.eh_*() functions and also the 547 * scsi_host_template.queuecommand() function). 548 */ 549 int srp_reconnect_rport(struct srp_rport *rport) 550 { 551 struct Scsi_Host *shost = rport_to_shost(rport); 552 struct srp_internal *i = to_srp_internal(shost->transportt); 553 struct scsi_device *sdev; 554 int res; 555 556 pr_debug("SCSI host %s\n", dev_name(&shost->shost_gendev)); 557 558 res = mutex_lock_interruptible(&rport->mutex); 559 if (res) 560 goto out; 561 scsi_target_block(&shost->shost_gendev); 562 while (scsi_request_fn_active(shost)) 563 msleep(20); 564 res = rport->state != SRP_RPORT_LOST ? i->f->reconnect(rport) : -ENODEV; 565 pr_debug("%s (state %d): transport.reconnect() returned %d\n", 566 dev_name(&shost->shost_gendev), rport->state, res); 567 if (res == 0) { 568 cancel_delayed_work(&rport->fast_io_fail_work); 569 cancel_delayed_work(&rport->dev_loss_work); 570 571 rport->failed_reconnects = 0; 572 srp_rport_set_state(rport, SRP_RPORT_RUNNING); 573 scsi_target_unblock(&shost->shost_gendev, SDEV_RUNNING); 574 /* 575 * If the SCSI error handler has offlined one or more devices, 576 * invoking scsi_target_unblock() won't change the state of 577 * these devices into running so do that explicitly. 578 */ 579 spin_lock_irq(shost->host_lock); 580 __shost_for_each_device(sdev, shost) 581 if (sdev->sdev_state == SDEV_OFFLINE) 582 sdev->sdev_state = SDEV_RUNNING; 583 spin_unlock_irq(shost->host_lock); 584 } else if (rport->state == SRP_RPORT_RUNNING) { 585 /* 586 * srp_reconnect_rport() has been invoked with fast_io_fail 587 * and dev_loss off. Mark the port as failed and start the TL 588 * failure timers if these had not yet been started. 589 */ 590 __rport_fail_io_fast(rport); 591 scsi_target_unblock(&shost->shost_gendev, 592 SDEV_TRANSPORT_OFFLINE); 593 __srp_start_tl_fail_timers(rport); 594 } else if (rport->state != SRP_RPORT_BLOCKED) { 595 scsi_target_unblock(&shost->shost_gendev, 596 SDEV_TRANSPORT_OFFLINE); 597 } 598 mutex_unlock(&rport->mutex); 599 600 out: 601 return res; 602 } 603 EXPORT_SYMBOL(srp_reconnect_rport); 604 605 /** 606 * srp_timed_out() - SRP transport intercept of the SCSI timeout EH 607 * @scmd: SCSI command. 608 * 609 * If a timeout occurs while an rport is in the blocked state, ask the SCSI 610 * EH to continue waiting (BLK_EH_RESET_TIMER). Otherwise let the SCSI core 611 * handle the timeout (BLK_EH_NOT_HANDLED). 612 * 613 * Note: This function is called from soft-IRQ context and with the request 614 * queue lock held. 615 */ 616 static enum blk_eh_timer_return srp_timed_out(struct scsi_cmnd *scmd) 617 { 618 struct scsi_device *sdev = scmd->device; 619 struct Scsi_Host *shost = sdev->host; 620 struct srp_internal *i = to_srp_internal(shost->transportt); 621 622 pr_debug("timeout for sdev %s\n", dev_name(&sdev->sdev_gendev)); 623 return i->f->reset_timer_if_blocked && scsi_device_blocked(sdev) ? 624 BLK_EH_RESET_TIMER : BLK_EH_NOT_HANDLED; 625 } 626 627 static void srp_rport_release(struct device *dev) 628 { 629 struct srp_rport *rport = dev_to_rport(dev); 630 631 put_device(dev->parent); 632 kfree(rport); 633 } 634 635 static int scsi_is_srp_rport(const struct device *dev) 636 { 637 return dev->release == srp_rport_release; 638 } 639 640 static int srp_rport_match(struct attribute_container *cont, 641 struct device *dev) 642 { 643 struct Scsi_Host *shost; 644 struct srp_internal *i; 645 646 if (!scsi_is_srp_rport(dev)) 647 return 0; 648 649 shost = dev_to_shost(dev->parent); 650 if (!shost->transportt) 651 return 0; 652 if (shost->transportt->host_attrs.ac.class != &srp_host_class.class) 653 return 0; 654 655 i = to_srp_internal(shost->transportt); 656 return &i->rport_attr_cont.ac == cont; 657 } 658 659 static int srp_host_match(struct attribute_container *cont, struct device *dev) 660 { 661 struct Scsi_Host *shost; 662 struct srp_internal *i; 663 664 if (!scsi_is_host_device(dev)) 665 return 0; 666 667 shost = dev_to_shost(dev); 668 if (!shost->transportt) 669 return 0; 670 if (shost->transportt->host_attrs.ac.class != &srp_host_class.class) 671 return 0; 672 673 i = to_srp_internal(shost->transportt); 674 return &i->t.host_attrs.ac == cont; 675 } 676 677 /** 678 * srp_rport_get() - increment rport reference count 679 * @rport: SRP target port. 680 */ 681 void srp_rport_get(struct srp_rport *rport) 682 { 683 get_device(&rport->dev); 684 } 685 EXPORT_SYMBOL(srp_rport_get); 686 687 /** 688 * srp_rport_put() - decrement rport reference count 689 * @rport: SRP target port. 690 */ 691 void srp_rport_put(struct srp_rport *rport) 692 { 693 put_device(&rport->dev); 694 } 695 EXPORT_SYMBOL(srp_rport_put); 696 697 /** 698 * srp_rport_add - add a SRP remote port to the device hierarchy 699 * @shost: scsi host the remote port is connected to. 700 * @ids: The port id for the remote port. 701 * 702 * Publishes a port to the rest of the system. 703 */ 704 struct srp_rport *srp_rport_add(struct Scsi_Host *shost, 705 struct srp_rport_identifiers *ids) 706 { 707 struct srp_rport *rport; 708 struct device *parent = &shost->shost_gendev; 709 struct srp_internal *i = to_srp_internal(shost->transportt); 710 int id, ret; 711 712 rport = kzalloc(sizeof(*rport), GFP_KERNEL); 713 if (!rport) 714 return ERR_PTR(-ENOMEM); 715 716 mutex_init(&rport->mutex); 717 718 device_initialize(&rport->dev); 719 720 rport->dev.parent = get_device(parent); 721 rport->dev.release = srp_rport_release; 722 723 memcpy(rport->port_id, ids->port_id, sizeof(rport->port_id)); 724 rport->roles = ids->roles; 725 726 if (i->f->reconnect) 727 rport->reconnect_delay = i->f->reconnect_delay ? 728 *i->f->reconnect_delay : 10; 729 INIT_DELAYED_WORK(&rport->reconnect_work, srp_reconnect_work); 730 rport->fast_io_fail_tmo = i->f->fast_io_fail_tmo ? 731 *i->f->fast_io_fail_tmo : 15; 732 rport->dev_loss_tmo = i->f->dev_loss_tmo ? *i->f->dev_loss_tmo : 60; 733 INIT_DELAYED_WORK(&rport->fast_io_fail_work, 734 rport_fast_io_fail_timedout); 735 INIT_DELAYED_WORK(&rport->dev_loss_work, rport_dev_loss_timedout); 736 737 id = atomic_inc_return(&to_srp_host_attrs(shost)->next_port_id); 738 dev_set_name(&rport->dev, "port-%d:%d", shost->host_no, id); 739 740 transport_setup_device(&rport->dev); 741 742 ret = device_add(&rport->dev); 743 if (ret) { 744 transport_destroy_device(&rport->dev); 745 put_device(&rport->dev); 746 return ERR_PTR(ret); 747 } 748 749 transport_add_device(&rport->dev); 750 transport_configure_device(&rport->dev); 751 752 return rport; 753 } 754 EXPORT_SYMBOL_GPL(srp_rport_add); 755 756 /** 757 * srp_rport_del - remove a SRP remote port 758 * @rport: SRP remote port to remove 759 * 760 * Removes the specified SRP remote port. 761 */ 762 void srp_rport_del(struct srp_rport *rport) 763 { 764 struct device *dev = &rport->dev; 765 766 transport_remove_device(dev); 767 device_del(dev); 768 transport_destroy_device(dev); 769 770 put_device(dev); 771 } 772 EXPORT_SYMBOL_GPL(srp_rport_del); 773 774 static int do_srp_rport_del(struct device *dev, void *data) 775 { 776 if (scsi_is_srp_rport(dev)) 777 srp_rport_del(dev_to_rport(dev)); 778 return 0; 779 } 780 781 /** 782 * srp_remove_host - tear down a Scsi_Host's SRP data structures 783 * @shost: Scsi Host that is torn down 784 * 785 * Removes all SRP remote ports for a given Scsi_Host. 786 * Must be called just before scsi_remove_host for SRP HBAs. 787 */ 788 void srp_remove_host(struct Scsi_Host *shost) 789 { 790 device_for_each_child(&shost->shost_gendev, NULL, do_srp_rport_del); 791 } 792 EXPORT_SYMBOL_GPL(srp_remove_host); 793 794 /** 795 * srp_stop_rport_timers - stop the transport layer recovery timers 796 * @rport: SRP remote port for which to stop the timers. 797 * 798 * Must be called after srp_remove_host() and scsi_remove_host(). The caller 799 * must hold a reference on the rport (rport->dev) and on the SCSI host 800 * (rport->dev.parent). 801 */ 802 void srp_stop_rport_timers(struct srp_rport *rport) 803 { 804 mutex_lock(&rport->mutex); 805 if (rport->state == SRP_RPORT_BLOCKED) 806 __rport_fail_io_fast(rport); 807 srp_rport_set_state(rport, SRP_RPORT_LOST); 808 mutex_unlock(&rport->mutex); 809 810 cancel_delayed_work_sync(&rport->reconnect_work); 811 cancel_delayed_work_sync(&rport->fast_io_fail_work); 812 cancel_delayed_work_sync(&rport->dev_loss_work); 813 } 814 EXPORT_SYMBOL_GPL(srp_stop_rport_timers); 815 816 static int srp_tsk_mgmt_response(struct Scsi_Host *shost, u64 nexus, u64 tm_id, 817 int result) 818 { 819 struct srp_internal *i = to_srp_internal(shost->transportt); 820 return i->f->tsk_mgmt_response(shost, nexus, tm_id, result); 821 } 822 823 static int srp_it_nexus_response(struct Scsi_Host *shost, u64 nexus, int result) 824 { 825 struct srp_internal *i = to_srp_internal(shost->transportt); 826 return i->f->it_nexus_response(shost, nexus, result); 827 } 828 829 /** 830 * srp_attach_transport - instantiate SRP transport template 831 * @ft: SRP transport class function template 832 */ 833 struct scsi_transport_template * 834 srp_attach_transport(struct srp_function_template *ft) 835 { 836 int count; 837 struct srp_internal *i; 838 839 i = kzalloc(sizeof(*i), GFP_KERNEL); 840 if (!i) 841 return NULL; 842 843 i->t.eh_timed_out = srp_timed_out; 844 845 i->t.tsk_mgmt_response = srp_tsk_mgmt_response; 846 i->t.it_nexus_response = srp_it_nexus_response; 847 848 i->t.host_size = sizeof(struct srp_host_attrs); 849 i->t.host_attrs.ac.attrs = &i->host_attrs[0]; 850 i->t.host_attrs.ac.class = &srp_host_class.class; 851 i->t.host_attrs.ac.match = srp_host_match; 852 i->host_attrs[0] = NULL; 853 transport_container_register(&i->t.host_attrs); 854 855 i->rport_attr_cont.ac.attrs = &i->rport_attrs[0]; 856 i->rport_attr_cont.ac.class = &srp_rport_class.class; 857 i->rport_attr_cont.ac.match = srp_rport_match; 858 859 count = 0; 860 i->rport_attrs[count++] = &dev_attr_port_id; 861 i->rport_attrs[count++] = &dev_attr_roles; 862 if (ft->has_rport_state) { 863 i->rport_attrs[count++] = &dev_attr_state; 864 i->rport_attrs[count++] = &dev_attr_fast_io_fail_tmo; 865 i->rport_attrs[count++] = &dev_attr_dev_loss_tmo; 866 } 867 if (ft->reconnect) { 868 i->rport_attrs[count++] = &dev_attr_reconnect_delay; 869 i->rport_attrs[count++] = &dev_attr_failed_reconnects; 870 } 871 if (ft->rport_delete) 872 i->rport_attrs[count++] = &dev_attr_delete; 873 i->rport_attrs[count++] = NULL; 874 BUG_ON(count > ARRAY_SIZE(i->rport_attrs)); 875 876 transport_container_register(&i->rport_attr_cont); 877 878 i->f = ft; 879 880 return &i->t; 881 } 882 EXPORT_SYMBOL_GPL(srp_attach_transport); 883 884 /** 885 * srp_release_transport - release SRP transport template instance 886 * @t: transport template instance 887 */ 888 void srp_release_transport(struct scsi_transport_template *t) 889 { 890 struct srp_internal *i = to_srp_internal(t); 891 892 transport_container_unregister(&i->t.host_attrs); 893 transport_container_unregister(&i->rport_attr_cont); 894 895 kfree(i); 896 } 897 EXPORT_SYMBOL_GPL(srp_release_transport); 898 899 static __init int srp_transport_init(void) 900 { 901 int ret; 902 903 ret = transport_class_register(&srp_host_class); 904 if (ret) 905 return ret; 906 ret = transport_class_register(&srp_rport_class); 907 if (ret) 908 goto unregister_host_class; 909 910 return 0; 911 unregister_host_class: 912 transport_class_unregister(&srp_host_class); 913 return ret; 914 } 915 916 static void __exit srp_transport_exit(void) 917 { 918 transport_class_unregister(&srp_host_class); 919 transport_class_unregister(&srp_rport_class); 920 } 921 922 MODULE_AUTHOR("FUJITA Tomonori"); 923 MODULE_DESCRIPTION("SRP Transport Attributes"); 924 MODULE_LICENSE("GPL"); 925 926 module_init(srp_transport_init); 927 module_exit(srp_transport_exit); 928