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