1 /*
2  *  FiberChannel transport specific attributes exported to sysfs.
3  *
4  *  Copyright (c) 2003 Silicon Graphics, Inc.  All rights reserved.
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 2 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  *  ========
21  *
22  *  Copyright (C) 2004-2007   James Smart, Emulex Corporation
23  *    Rewrite for host, target, device, and remote port attributes,
24  *    statistics, and service functions...
25  *    Add vports, etc
26  *
27  */
28 #include <linux/module.h>
29 #include <linux/init.h>
30 #include <linux/slab.h>
31 #include <linux/delay.h>
32 #include <linux/kernel.h>
33 #include <linux/bsg-lib.h>
34 #include <scsi/scsi_device.h>
35 #include <scsi/scsi_host.h>
36 #include <scsi/scsi_transport.h>
37 #include <scsi/scsi_transport_fc.h>
38 #include <scsi/scsi_cmnd.h>
39 #include <net/netlink.h>
40 #include <scsi/scsi_netlink_fc.h>
41 #include <scsi/scsi_bsg_fc.h>
42 #include "scsi_priv.h"
43 
44 static int fc_queue_work(struct Scsi_Host *, struct work_struct *);
45 static void fc_vport_sched_delete(struct work_struct *work);
46 static int fc_vport_setup(struct Scsi_Host *shost, int channel,
47 	struct device *pdev, struct fc_vport_identifiers  *ids,
48 	struct fc_vport **vport);
49 static int fc_bsg_hostadd(struct Scsi_Host *, struct fc_host_attrs *);
50 static int fc_bsg_rportadd(struct Scsi_Host *, struct fc_rport *);
51 static void fc_bsg_remove(struct request_queue *);
52 static void fc_bsg_goose_queue(struct fc_rport *);
53 
54 /*
55  * Module Parameters
56  */
57 
58 /*
59  * dev_loss_tmo: the default number of seconds that the FC transport
60  *   should insulate the loss of a remote port.
61  *   The maximum will be capped by the value of SCSI_DEVICE_BLOCK_MAX_TIMEOUT.
62  */
63 static unsigned int fc_dev_loss_tmo = 60;		/* seconds */
64 
65 module_param_named(dev_loss_tmo, fc_dev_loss_tmo, uint, S_IRUGO|S_IWUSR);
66 MODULE_PARM_DESC(dev_loss_tmo,
67 		 "Maximum number of seconds that the FC transport should"
68 		 " insulate the loss of a remote port. Once this value is"
69 		 " exceeded, the scsi target is removed. Value should be"
70 		 " between 1 and SCSI_DEVICE_BLOCK_MAX_TIMEOUT if"
71 		 " fast_io_fail_tmo is not set.");
72 
73 /*
74  * Redefine so that we can have same named attributes in the
75  * sdev/starget/host objects.
76  */
77 #define FC_DEVICE_ATTR(_prefix,_name,_mode,_show,_store)		\
78 struct device_attribute device_attr_##_prefix##_##_name = 	\
79 	__ATTR(_name,_mode,_show,_store)
80 
81 #define fc_enum_name_search(title, table_type, table)			\
82 static const char *get_fc_##title##_name(enum table_type table_key)	\
83 {									\
84 	int i;								\
85 	char *name = NULL;						\
86 									\
87 	for (i = 0; i < ARRAY_SIZE(table); i++) {			\
88 		if (table[i].value == table_key) {			\
89 			name = table[i].name;				\
90 			break;						\
91 		}							\
92 	}								\
93 	return name;							\
94 }
95 
96 #define fc_enum_name_match(title, table_type, table)			\
97 static int get_fc_##title##_match(const char *table_key,		\
98 		enum table_type *value)					\
99 {									\
100 	int i;								\
101 									\
102 	for (i = 0; i < ARRAY_SIZE(table); i++) {			\
103 		if (strncmp(table_key, table[i].name,			\
104 				table[i].matchlen) == 0) {		\
105 			*value = table[i].value;			\
106 			return 0; /* success */				\
107 		}							\
108 	}								\
109 	return 1; /* failure */						\
110 }
111 
112 
113 /* Convert fc_port_type values to ascii string name */
114 static struct {
115 	enum fc_port_type	value;
116 	char			*name;
117 } fc_port_type_names[] = {
118 	{ FC_PORTTYPE_UNKNOWN,		"Unknown" },
119 	{ FC_PORTTYPE_OTHER,		"Other" },
120 	{ FC_PORTTYPE_NOTPRESENT,	"Not Present" },
121 	{ FC_PORTTYPE_NPORT,	"NPort (fabric via point-to-point)" },
122 	{ FC_PORTTYPE_NLPORT,	"NLPort (fabric via loop)" },
123 	{ FC_PORTTYPE_LPORT,	"LPort (private loop)" },
124 	{ FC_PORTTYPE_PTP,	"Point-To-Point (direct nport connection)" },
125 	{ FC_PORTTYPE_NPIV,		"NPIV VPORT" },
126 };
127 fc_enum_name_search(port_type, fc_port_type, fc_port_type_names)
128 #define FC_PORTTYPE_MAX_NAMELEN		50
129 
130 /* Reuse fc_port_type enum function for vport_type */
131 #define get_fc_vport_type_name get_fc_port_type_name
132 
133 
134 /* Convert fc_host_event_code values to ascii string name */
135 static const struct {
136 	enum fc_host_event_code		value;
137 	char				*name;
138 } fc_host_event_code_names[] = {
139 	{ FCH_EVT_LIP,			"lip" },
140 	{ FCH_EVT_LINKUP,		"link_up" },
141 	{ FCH_EVT_LINKDOWN,		"link_down" },
142 	{ FCH_EVT_LIPRESET,		"lip_reset" },
143 	{ FCH_EVT_RSCN,			"rscn" },
144 	{ FCH_EVT_ADAPTER_CHANGE,	"adapter_chg" },
145 	{ FCH_EVT_PORT_UNKNOWN,		"port_unknown" },
146 	{ FCH_EVT_PORT_ONLINE,		"port_online" },
147 	{ FCH_EVT_PORT_OFFLINE,		"port_offline" },
148 	{ FCH_EVT_PORT_FABRIC,		"port_fabric" },
149 	{ FCH_EVT_LINK_UNKNOWN,		"link_unknown" },
150 	{ FCH_EVT_VENDOR_UNIQUE,	"vendor_unique" },
151 };
152 fc_enum_name_search(host_event_code, fc_host_event_code,
153 		fc_host_event_code_names)
154 #define FC_HOST_EVENT_CODE_MAX_NAMELEN	30
155 
156 
157 /* Convert fc_port_state values to ascii string name */
158 static struct {
159 	enum fc_port_state	value;
160 	char			*name;
161 } fc_port_state_names[] = {
162 	{ FC_PORTSTATE_UNKNOWN,		"Unknown" },
163 	{ FC_PORTSTATE_NOTPRESENT,	"Not Present" },
164 	{ FC_PORTSTATE_ONLINE,		"Online" },
165 	{ FC_PORTSTATE_OFFLINE,		"Offline" },
166 	{ FC_PORTSTATE_BLOCKED,		"Blocked" },
167 	{ FC_PORTSTATE_BYPASSED,	"Bypassed" },
168 	{ FC_PORTSTATE_DIAGNOSTICS,	"Diagnostics" },
169 	{ FC_PORTSTATE_LINKDOWN,	"Linkdown" },
170 	{ FC_PORTSTATE_ERROR,		"Error" },
171 	{ FC_PORTSTATE_LOOPBACK,	"Loopback" },
172 	{ FC_PORTSTATE_DELETED,		"Deleted" },
173 };
174 fc_enum_name_search(port_state, fc_port_state, fc_port_state_names)
175 #define FC_PORTSTATE_MAX_NAMELEN	20
176 
177 
178 /* Convert fc_vport_state values to ascii string name */
179 static struct {
180 	enum fc_vport_state	value;
181 	char			*name;
182 } fc_vport_state_names[] = {
183 	{ FC_VPORT_UNKNOWN,		"Unknown" },
184 	{ FC_VPORT_ACTIVE,		"Active" },
185 	{ FC_VPORT_DISABLED,		"Disabled" },
186 	{ FC_VPORT_LINKDOWN,		"Linkdown" },
187 	{ FC_VPORT_INITIALIZING,	"Initializing" },
188 	{ FC_VPORT_NO_FABRIC_SUPP,	"No Fabric Support" },
189 	{ FC_VPORT_NO_FABRIC_RSCS,	"No Fabric Resources" },
190 	{ FC_VPORT_FABRIC_LOGOUT,	"Fabric Logout" },
191 	{ FC_VPORT_FABRIC_REJ_WWN,	"Fabric Rejected WWN" },
192 	{ FC_VPORT_FAILED,		"VPort Failed" },
193 };
194 fc_enum_name_search(vport_state, fc_vport_state, fc_vport_state_names)
195 #define FC_VPORTSTATE_MAX_NAMELEN	24
196 
197 /* Reuse fc_vport_state enum function for vport_last_state */
198 #define get_fc_vport_last_state_name get_fc_vport_state_name
199 
200 
201 /* Convert fc_tgtid_binding_type values to ascii string name */
202 static const struct {
203 	enum fc_tgtid_binding_type	value;
204 	char				*name;
205 	int				matchlen;
206 } fc_tgtid_binding_type_names[] = {
207 	{ FC_TGTID_BIND_NONE, "none", 4 },
208 	{ FC_TGTID_BIND_BY_WWPN, "wwpn (World Wide Port Name)", 4 },
209 	{ FC_TGTID_BIND_BY_WWNN, "wwnn (World Wide Node Name)", 4 },
210 	{ FC_TGTID_BIND_BY_ID, "port_id (FC Address)", 7 },
211 };
212 fc_enum_name_search(tgtid_bind_type, fc_tgtid_binding_type,
213 		fc_tgtid_binding_type_names)
214 fc_enum_name_match(tgtid_bind_type, fc_tgtid_binding_type,
215 		fc_tgtid_binding_type_names)
216 #define FC_BINDTYPE_MAX_NAMELEN	30
217 
218 
219 #define fc_bitfield_name_search(title, table)			\
220 static ssize_t							\
221 get_fc_##title##_names(u32 table_key, char *buf)		\
222 {								\
223 	char *prefix = "";					\
224 	ssize_t len = 0;					\
225 	int i;							\
226 								\
227 	for (i = 0; i < ARRAY_SIZE(table); i++) {		\
228 		if (table[i].value & table_key) {		\
229 			len += sprintf(buf + len, "%s%s",	\
230 				prefix, table[i].name);		\
231 			prefix = ", ";				\
232 		}						\
233 	}							\
234 	len += sprintf(buf + len, "\n");			\
235 	return len;						\
236 }
237 
238 
239 /* Convert FC_COS bit values to ascii string name */
240 static const struct {
241 	u32 			value;
242 	char			*name;
243 } fc_cos_names[] = {
244 	{ FC_COS_CLASS1,	"Class 1" },
245 	{ FC_COS_CLASS2,	"Class 2" },
246 	{ FC_COS_CLASS3,	"Class 3" },
247 	{ FC_COS_CLASS4,	"Class 4" },
248 	{ FC_COS_CLASS6,	"Class 6" },
249 };
250 fc_bitfield_name_search(cos, fc_cos_names)
251 
252 
253 /* Convert FC_PORTSPEED bit values to ascii string name */
254 static const struct {
255 	u32 			value;
256 	char			*name;
257 } fc_port_speed_names[] = {
258 	{ FC_PORTSPEED_1GBIT,		"1 Gbit" },
259 	{ FC_PORTSPEED_2GBIT,		"2 Gbit" },
260 	{ FC_PORTSPEED_4GBIT,		"4 Gbit" },
261 	{ FC_PORTSPEED_10GBIT,		"10 Gbit" },
262 	{ FC_PORTSPEED_8GBIT,		"8 Gbit" },
263 	{ FC_PORTSPEED_16GBIT,		"16 Gbit" },
264 	{ FC_PORTSPEED_32GBIT,		"32 Gbit" },
265 	{ FC_PORTSPEED_20GBIT,		"20 Gbit" },
266 	{ FC_PORTSPEED_40GBIT,		"40 Gbit" },
267 	{ FC_PORTSPEED_50GBIT,		"50 Gbit" },
268 	{ FC_PORTSPEED_100GBIT,		"100 Gbit" },
269 	{ FC_PORTSPEED_25GBIT,		"25 Gbit" },
270 	{ FC_PORTSPEED_64GBIT,		"64 Gbit" },
271 	{ FC_PORTSPEED_128GBIT,		"128 Gbit" },
272 	{ FC_PORTSPEED_NOT_NEGOTIATED,	"Not Negotiated" },
273 };
274 fc_bitfield_name_search(port_speed, fc_port_speed_names)
275 
276 
277 static int
278 show_fc_fc4s (char *buf, u8 *fc4_list)
279 {
280 	int i, len=0;
281 
282 	for (i = 0; i < FC_FC4_LIST_SIZE; i++, fc4_list++)
283 		len += sprintf(buf + len , "0x%02x ", *fc4_list);
284 	len += sprintf(buf + len, "\n");
285 	return len;
286 }
287 
288 
289 /* Convert FC_PORT_ROLE bit values to ascii string name */
290 static const struct {
291 	u32 			value;
292 	char			*name;
293 } fc_port_role_names[] = {
294 	{ FC_PORT_ROLE_FCP_TARGET,		"FCP Target" },
295 	{ FC_PORT_ROLE_FCP_INITIATOR,		"FCP Initiator" },
296 	{ FC_PORT_ROLE_IP_PORT,			"IP Port" },
297 	{ FC_PORT_ROLE_FCP_DUMMY_INITIATOR,	"FCP Dummy Initiator" },
298 };
299 fc_bitfield_name_search(port_roles, fc_port_role_names)
300 
301 /*
302  * Define roles that are specific to port_id. Values are relative to ROLE_MASK.
303  */
304 #define FC_WELLKNOWN_PORTID_MASK	0xfffff0
305 #define FC_WELLKNOWN_ROLE_MASK  	0x00000f
306 #define FC_FPORT_PORTID			0x00000e
307 #define FC_FABCTLR_PORTID		0x00000d
308 #define FC_DIRSRVR_PORTID		0x00000c
309 #define FC_TIMESRVR_PORTID		0x00000b
310 #define FC_MGMTSRVR_PORTID		0x00000a
311 
312 
313 static void fc_timeout_deleted_rport(struct work_struct *work);
314 static void fc_timeout_fail_rport_io(struct work_struct *work);
315 static void fc_scsi_scan_rport(struct work_struct *work);
316 
317 /*
318  * Attribute counts pre object type...
319  * Increase these values if you add attributes
320  */
321 #define FC_STARGET_NUM_ATTRS 	3
322 #define FC_RPORT_NUM_ATTRS	10
323 #define FC_VPORT_NUM_ATTRS	9
324 #define FC_HOST_NUM_ATTRS	29
325 
326 struct fc_internal {
327 	struct scsi_transport_template t;
328 	struct fc_function_template *f;
329 
330 	/*
331 	 * For attributes : each object has :
332 	 *   An array of the actual attributes structures
333 	 *   An array of null-terminated pointers to the attribute
334 	 *     structures - used for mid-layer interaction.
335 	 *
336 	 * The attribute containers for the starget and host are are
337 	 * part of the midlayer. As the remote port is specific to the
338 	 * fc transport, we must provide the attribute container.
339 	 */
340 	struct device_attribute private_starget_attrs[
341 							FC_STARGET_NUM_ATTRS];
342 	struct device_attribute *starget_attrs[FC_STARGET_NUM_ATTRS + 1];
343 
344 	struct device_attribute private_host_attrs[FC_HOST_NUM_ATTRS];
345 	struct device_attribute *host_attrs[FC_HOST_NUM_ATTRS + 1];
346 
347 	struct transport_container rport_attr_cont;
348 	struct device_attribute private_rport_attrs[FC_RPORT_NUM_ATTRS];
349 	struct device_attribute *rport_attrs[FC_RPORT_NUM_ATTRS + 1];
350 
351 	struct transport_container vport_attr_cont;
352 	struct device_attribute private_vport_attrs[FC_VPORT_NUM_ATTRS];
353 	struct device_attribute *vport_attrs[FC_VPORT_NUM_ATTRS + 1];
354 };
355 
356 #define to_fc_internal(tmpl)	container_of(tmpl, struct fc_internal, t)
357 
358 static int fc_target_setup(struct transport_container *tc, struct device *dev,
359 			   struct device *cdev)
360 {
361 	struct scsi_target *starget = to_scsi_target(dev);
362 	struct fc_rport *rport = starget_to_rport(starget);
363 
364 	/*
365 	 * if parent is remote port, use values from remote port.
366 	 * Otherwise, this host uses the fc_transport, but not the
367 	 * remote port interface. As such, initialize to known non-values.
368 	 */
369 	if (rport) {
370 		fc_starget_node_name(starget) = rport->node_name;
371 		fc_starget_port_name(starget) = rport->port_name;
372 		fc_starget_port_id(starget) = rport->port_id;
373 	} else {
374 		fc_starget_node_name(starget) = -1;
375 		fc_starget_port_name(starget) = -1;
376 		fc_starget_port_id(starget) = -1;
377 	}
378 
379 	return 0;
380 }
381 
382 static DECLARE_TRANSPORT_CLASS(fc_transport_class,
383 			       "fc_transport",
384 			       fc_target_setup,
385 			       NULL,
386 			       NULL);
387 
388 static int fc_host_setup(struct transport_container *tc, struct device *dev,
389 			 struct device *cdev)
390 {
391 	struct Scsi_Host *shost = dev_to_shost(dev);
392 	struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
393 
394 	/*
395 	 * Set default values easily detected by the midlayer as
396 	 * failure cases.  The scsi lldd is responsible for initializing
397 	 * all transport attributes to valid values per host.
398 	 */
399 	fc_host->node_name = -1;
400 	fc_host->port_name = -1;
401 	fc_host->permanent_port_name = -1;
402 	fc_host->supported_classes = FC_COS_UNSPECIFIED;
403 	memset(fc_host->supported_fc4s, 0,
404 		sizeof(fc_host->supported_fc4s));
405 	fc_host->supported_speeds = FC_PORTSPEED_UNKNOWN;
406 	fc_host->maxframe_size = -1;
407 	fc_host->max_npiv_vports = 0;
408 	memset(fc_host->serial_number, 0,
409 		sizeof(fc_host->serial_number));
410 	memset(fc_host->manufacturer, 0,
411 		sizeof(fc_host->manufacturer));
412 	memset(fc_host->model, 0,
413 		sizeof(fc_host->model));
414 	memset(fc_host->model_description, 0,
415 		sizeof(fc_host->model_description));
416 	memset(fc_host->hardware_version, 0,
417 		sizeof(fc_host->hardware_version));
418 	memset(fc_host->driver_version, 0,
419 		sizeof(fc_host->driver_version));
420 	memset(fc_host->firmware_version, 0,
421 		sizeof(fc_host->firmware_version));
422 	memset(fc_host->optionrom_version, 0,
423 		sizeof(fc_host->optionrom_version));
424 
425 	fc_host->port_id = -1;
426 	fc_host->port_type = FC_PORTTYPE_UNKNOWN;
427 	fc_host->port_state = FC_PORTSTATE_UNKNOWN;
428 	memset(fc_host->active_fc4s, 0,
429 		sizeof(fc_host->active_fc4s));
430 	fc_host->speed = FC_PORTSPEED_UNKNOWN;
431 	fc_host->fabric_name = -1;
432 	memset(fc_host->symbolic_name, 0, sizeof(fc_host->symbolic_name));
433 	memset(fc_host->system_hostname, 0, sizeof(fc_host->system_hostname));
434 
435 	fc_host->tgtid_bind_type = FC_TGTID_BIND_BY_WWPN;
436 
437 	INIT_LIST_HEAD(&fc_host->rports);
438 	INIT_LIST_HEAD(&fc_host->rport_bindings);
439 	INIT_LIST_HEAD(&fc_host->vports);
440 	fc_host->next_rport_number = 0;
441 	fc_host->next_target_id = 0;
442 	fc_host->next_vport_number = 0;
443 	fc_host->npiv_vports_inuse = 0;
444 
445 	snprintf(fc_host->work_q_name, sizeof(fc_host->work_q_name),
446 		 "fc_wq_%d", shost->host_no);
447 	fc_host->work_q = alloc_workqueue("%s", 0, 0, fc_host->work_q_name);
448 	if (!fc_host->work_q)
449 		return -ENOMEM;
450 
451 	fc_host->dev_loss_tmo = fc_dev_loss_tmo;
452 	snprintf(fc_host->devloss_work_q_name,
453 		 sizeof(fc_host->devloss_work_q_name),
454 		 "fc_dl_%d", shost->host_no);
455 	fc_host->devloss_work_q = alloc_workqueue("%s", 0, 0,
456 					fc_host->devloss_work_q_name);
457 	if (!fc_host->devloss_work_q) {
458 		destroy_workqueue(fc_host->work_q);
459 		fc_host->work_q = NULL;
460 		return -ENOMEM;
461 	}
462 
463 	fc_bsg_hostadd(shost, fc_host);
464 	/* ignore any bsg add error - we just can't do sgio */
465 
466 	return 0;
467 }
468 
469 static int fc_host_remove(struct transport_container *tc, struct device *dev,
470 			 struct device *cdev)
471 {
472 	struct Scsi_Host *shost = dev_to_shost(dev);
473 	struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
474 
475 	fc_bsg_remove(fc_host->rqst_q);
476 	return 0;
477 }
478 
479 static DECLARE_TRANSPORT_CLASS(fc_host_class,
480 			       "fc_host",
481 			       fc_host_setup,
482 			       fc_host_remove,
483 			       NULL);
484 
485 /*
486  * Setup and Remove actions for remote ports are handled
487  * in the service functions below.
488  */
489 static DECLARE_TRANSPORT_CLASS(fc_rport_class,
490 			       "fc_remote_ports",
491 			       NULL,
492 			       NULL,
493 			       NULL);
494 
495 /*
496  * Setup and Remove actions for virtual ports are handled
497  * in the service functions below.
498  */
499 static DECLARE_TRANSPORT_CLASS(fc_vport_class,
500 			       "fc_vports",
501 			       NULL,
502 			       NULL,
503 			       NULL);
504 
505 /*
506  * Netlink Infrastructure
507  */
508 
509 static atomic_t fc_event_seq;
510 
511 /**
512  * fc_get_event_number - Obtain the next sequential FC event number
513  *
514  * Notes:
515  *   We could have inlined this, but it would have required fc_event_seq to
516  *   be exposed. For now, live with the subroutine call.
517  *   Atomic used to avoid lock/unlock...
518  */
519 u32
520 fc_get_event_number(void)
521 {
522 	return atomic_add_return(1, &fc_event_seq);
523 }
524 EXPORT_SYMBOL(fc_get_event_number);
525 
526 
527 /**
528  * fc_host_post_event - called to post an even on an fc_host.
529  * @shost:		host the event occurred on
530  * @event_number:	fc event number obtained from get_fc_event_number()
531  * @event_code:		fc_host event being posted
532  * @event_data:		32bits of data for the event being posted
533  *
534  * Notes:
535  *	This routine assumes no locks are held on entry.
536  */
537 void
538 fc_host_post_event(struct Scsi_Host *shost, u32 event_number,
539 		enum fc_host_event_code event_code, u32 event_data)
540 {
541 	struct sk_buff *skb;
542 	struct nlmsghdr	*nlh;
543 	struct fc_nl_event *event;
544 	const char *name;
545 	u32 len;
546 	int err;
547 
548 	if (!scsi_nl_sock) {
549 		err = -ENOENT;
550 		goto send_fail;
551 	}
552 
553 	len = FC_NL_MSGALIGN(sizeof(*event));
554 
555 	skb = nlmsg_new(len, GFP_KERNEL);
556 	if (!skb) {
557 		err = -ENOBUFS;
558 		goto send_fail;
559 	}
560 
561 	nlh = nlmsg_put(skb, 0, 0, SCSI_TRANSPORT_MSG, len, 0);
562 	if (!nlh) {
563 		err = -ENOBUFS;
564 		goto send_fail_skb;
565 	}
566 	event = nlmsg_data(nlh);
567 
568 	INIT_SCSI_NL_HDR(&event->snlh, SCSI_NL_TRANSPORT_FC,
569 				FC_NL_ASYNC_EVENT, len);
570 	event->seconds = ktime_get_real_seconds();
571 	event->vendor_id = 0;
572 	event->host_no = shost->host_no;
573 	event->event_datalen = sizeof(u32);	/* bytes */
574 	event->event_num = event_number;
575 	event->event_code = event_code;
576 	event->event_data = event_data;
577 
578 	nlmsg_multicast(scsi_nl_sock, skb, 0, SCSI_NL_GRP_FC_EVENTS,
579 			GFP_KERNEL);
580 	return;
581 
582 send_fail_skb:
583 	kfree_skb(skb);
584 send_fail:
585 	name = get_fc_host_event_code_name(event_code);
586 	printk(KERN_WARNING
587 		"%s: Dropped Event : host %d %s data 0x%08x - err %d\n",
588 		__func__, shost->host_no,
589 		(name) ? name : "<unknown>", event_data, err);
590 	return;
591 }
592 EXPORT_SYMBOL(fc_host_post_event);
593 
594 
595 /**
596  * fc_host_post_vendor_event - called to post a vendor unique event on an fc_host
597  * @shost:		host the event occurred on
598  * @event_number:	fc event number obtained from get_fc_event_number()
599  * @data_len:		amount, in bytes, of vendor unique data
600  * @data_buf:		pointer to vendor unique data
601  * @vendor_id:          Vendor id
602  *
603  * Notes:
604  *	This routine assumes no locks are held on entry.
605  */
606 void
607 fc_host_post_vendor_event(struct Scsi_Host *shost, u32 event_number,
608 		u32 data_len, char * data_buf, u64 vendor_id)
609 {
610 	struct sk_buff *skb;
611 	struct nlmsghdr	*nlh;
612 	struct fc_nl_event *event;
613 	u32 len;
614 	int err;
615 
616 	if (!scsi_nl_sock) {
617 		err = -ENOENT;
618 		goto send_vendor_fail;
619 	}
620 
621 	len = FC_NL_MSGALIGN(sizeof(*event) + data_len);
622 
623 	skb = nlmsg_new(len, GFP_KERNEL);
624 	if (!skb) {
625 		err = -ENOBUFS;
626 		goto send_vendor_fail;
627 	}
628 
629 	nlh = nlmsg_put(skb, 0, 0, SCSI_TRANSPORT_MSG, len, 0);
630 	if (!nlh) {
631 		err = -ENOBUFS;
632 		goto send_vendor_fail_skb;
633 	}
634 	event = nlmsg_data(nlh);
635 
636 	INIT_SCSI_NL_HDR(&event->snlh, SCSI_NL_TRANSPORT_FC,
637 				FC_NL_ASYNC_EVENT, len);
638 	event->seconds = ktime_get_real_seconds();
639 	event->vendor_id = vendor_id;
640 	event->host_no = shost->host_no;
641 	event->event_datalen = data_len;	/* bytes */
642 	event->event_num = event_number;
643 	event->event_code = FCH_EVT_VENDOR_UNIQUE;
644 	memcpy(&event->event_data, data_buf, data_len);
645 
646 	nlmsg_multicast(scsi_nl_sock, skb, 0, SCSI_NL_GRP_FC_EVENTS,
647 			GFP_KERNEL);
648 	return;
649 
650 send_vendor_fail_skb:
651 	kfree_skb(skb);
652 send_vendor_fail:
653 	printk(KERN_WARNING
654 		"%s: Dropped Event : host %d vendor_unique - err %d\n",
655 		__func__, shost->host_no, err);
656 	return;
657 }
658 EXPORT_SYMBOL(fc_host_post_vendor_event);
659 
660 
661 
662 static __init int fc_transport_init(void)
663 {
664 	int error;
665 
666 	atomic_set(&fc_event_seq, 0);
667 
668 	error = transport_class_register(&fc_host_class);
669 	if (error)
670 		return error;
671 	error = transport_class_register(&fc_vport_class);
672 	if (error)
673 		goto unreg_host_class;
674 	error = transport_class_register(&fc_rport_class);
675 	if (error)
676 		goto unreg_vport_class;
677 	error = transport_class_register(&fc_transport_class);
678 	if (error)
679 		goto unreg_rport_class;
680 	return 0;
681 
682 unreg_rport_class:
683 	transport_class_unregister(&fc_rport_class);
684 unreg_vport_class:
685 	transport_class_unregister(&fc_vport_class);
686 unreg_host_class:
687 	transport_class_unregister(&fc_host_class);
688 	return error;
689 }
690 
691 static void __exit fc_transport_exit(void)
692 {
693 	transport_class_unregister(&fc_transport_class);
694 	transport_class_unregister(&fc_rport_class);
695 	transport_class_unregister(&fc_host_class);
696 	transport_class_unregister(&fc_vport_class);
697 }
698 
699 /*
700  * FC Remote Port Attribute Management
701  */
702 
703 #define fc_rport_show_function(field, format_string, sz, cast)		\
704 static ssize_t								\
705 show_fc_rport_##field (struct device *dev, 				\
706 		       struct device_attribute *attr, char *buf)	\
707 {									\
708 	struct fc_rport *rport = transport_class_to_rport(dev);		\
709 	struct Scsi_Host *shost = rport_to_shost(rport);		\
710 	struct fc_internal *i = to_fc_internal(shost->transportt);	\
711 	if ((i->f->get_rport_##field) &&				\
712 	    !((rport->port_state == FC_PORTSTATE_BLOCKED) ||		\
713 	      (rport->port_state == FC_PORTSTATE_DELETED) ||		\
714 	      (rport->port_state == FC_PORTSTATE_NOTPRESENT)))		\
715 		i->f->get_rport_##field(rport);				\
716 	return snprintf(buf, sz, format_string, cast rport->field); 	\
717 }
718 
719 #define fc_rport_store_function(field)					\
720 static ssize_t								\
721 store_fc_rport_##field(struct device *dev,				\
722 		       struct device_attribute *attr,			\
723 		       const char *buf,	size_t count)			\
724 {									\
725 	int val;							\
726 	struct fc_rport *rport = transport_class_to_rport(dev);		\
727 	struct Scsi_Host *shost = rport_to_shost(rport);		\
728 	struct fc_internal *i = to_fc_internal(shost->transportt);	\
729 	char *cp;							\
730 	if ((rport->port_state == FC_PORTSTATE_BLOCKED) ||		\
731 	    (rport->port_state == FC_PORTSTATE_DELETED) ||		\
732 	    (rport->port_state == FC_PORTSTATE_NOTPRESENT))		\
733 		return -EBUSY;						\
734 	val = simple_strtoul(buf, &cp, 0);				\
735 	if (*cp && (*cp != '\n'))					\
736 		return -EINVAL;						\
737 	i->f->set_rport_##field(rport, val);				\
738 	return count;							\
739 }
740 
741 #define fc_rport_rd_attr(field, format_string, sz)			\
742 	fc_rport_show_function(field, format_string, sz, )		\
743 static FC_DEVICE_ATTR(rport, field, S_IRUGO,			\
744 			 show_fc_rport_##field, NULL)
745 
746 #define fc_rport_rd_attr_cast(field, format_string, sz, cast)		\
747 	fc_rport_show_function(field, format_string, sz, (cast))	\
748 static FC_DEVICE_ATTR(rport, field, S_IRUGO,			\
749 			  show_fc_rport_##field, NULL)
750 
751 #define fc_rport_rw_attr(field, format_string, sz)			\
752 	fc_rport_show_function(field, format_string, sz, )		\
753 	fc_rport_store_function(field)					\
754 static FC_DEVICE_ATTR(rport, field, S_IRUGO | S_IWUSR,		\
755 			show_fc_rport_##field,				\
756 			store_fc_rport_##field)
757 
758 
759 #define fc_private_rport_show_function(field, format_string, sz, cast)	\
760 static ssize_t								\
761 show_fc_rport_##field (struct device *dev, 				\
762 		       struct device_attribute *attr, char *buf)	\
763 {									\
764 	struct fc_rport *rport = transport_class_to_rport(dev);		\
765 	return snprintf(buf, sz, format_string, cast rport->field); 	\
766 }
767 
768 #define fc_private_rport_rd_attr(field, format_string, sz)		\
769 	fc_private_rport_show_function(field, format_string, sz, )	\
770 static FC_DEVICE_ATTR(rport, field, S_IRUGO,			\
771 			 show_fc_rport_##field, NULL)
772 
773 #define fc_private_rport_rd_attr_cast(field, format_string, sz, cast)	\
774 	fc_private_rport_show_function(field, format_string, sz, (cast)) \
775 static FC_DEVICE_ATTR(rport, field, S_IRUGO,			\
776 			  show_fc_rport_##field, NULL)
777 
778 
779 #define fc_private_rport_rd_enum_attr(title, maxlen)			\
780 static ssize_t								\
781 show_fc_rport_##title (struct device *dev,				\
782 		       struct device_attribute *attr, char *buf)	\
783 {									\
784 	struct fc_rport *rport = transport_class_to_rport(dev);		\
785 	const char *name;						\
786 	name = get_fc_##title##_name(rport->title);			\
787 	if (!name)							\
788 		return -EINVAL;						\
789 	return snprintf(buf, maxlen, "%s\n", name);			\
790 }									\
791 static FC_DEVICE_ATTR(rport, title, S_IRUGO,			\
792 			show_fc_rport_##title, NULL)
793 
794 
795 #define SETUP_RPORT_ATTRIBUTE_RD(field)					\
796 	i->private_rport_attrs[count] = device_attr_rport_##field; \
797 	i->private_rport_attrs[count].attr.mode = S_IRUGO;		\
798 	i->private_rport_attrs[count].store = NULL;			\
799 	i->rport_attrs[count] = &i->private_rport_attrs[count];		\
800 	if (i->f->show_rport_##field)					\
801 		count++
802 
803 #define SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(field)				\
804 	i->private_rport_attrs[count] = device_attr_rport_##field; \
805 	i->private_rport_attrs[count].attr.mode = S_IRUGO;		\
806 	i->private_rport_attrs[count].store = NULL;			\
807 	i->rport_attrs[count] = &i->private_rport_attrs[count];		\
808 	count++
809 
810 #define SETUP_RPORT_ATTRIBUTE_RW(field)					\
811 	i->private_rport_attrs[count] = device_attr_rport_##field; \
812 	if (!i->f->set_rport_##field) {					\
813 		i->private_rport_attrs[count].attr.mode = S_IRUGO;	\
814 		i->private_rport_attrs[count].store = NULL;		\
815 	}								\
816 	i->rport_attrs[count] = &i->private_rport_attrs[count];		\
817 	if (i->f->show_rport_##field)					\
818 		count++
819 
820 #define SETUP_PRIVATE_RPORT_ATTRIBUTE_RW(field)				\
821 {									\
822 	i->private_rport_attrs[count] = device_attr_rport_##field; \
823 	i->rport_attrs[count] = &i->private_rport_attrs[count];		\
824 	count++;							\
825 }
826 
827 
828 /* The FC Transport Remote Port Attributes: */
829 
830 /* Fixed Remote Port Attributes */
831 
832 fc_private_rport_rd_attr(maxframe_size, "%u bytes\n", 20);
833 
834 static ssize_t
835 show_fc_rport_supported_classes (struct device *dev,
836 				 struct device_attribute *attr, char *buf)
837 {
838 	struct fc_rport *rport = transport_class_to_rport(dev);
839 	if (rport->supported_classes == FC_COS_UNSPECIFIED)
840 		return snprintf(buf, 20, "unspecified\n");
841 	return get_fc_cos_names(rport->supported_classes, buf);
842 }
843 static FC_DEVICE_ATTR(rport, supported_classes, S_IRUGO,
844 		show_fc_rport_supported_classes, NULL);
845 
846 /* Dynamic Remote Port Attributes */
847 
848 /*
849  * dev_loss_tmo attribute
850  */
851 static int fc_str_to_dev_loss(const char *buf, unsigned long *val)
852 {
853 	char *cp;
854 
855 	*val = simple_strtoul(buf, &cp, 0);
856 	if (*cp && (*cp != '\n'))
857 		return -EINVAL;
858 	/*
859 	 * Check for overflow; dev_loss_tmo is u32
860 	 */
861 	if (*val > UINT_MAX)
862 		return -EINVAL;
863 
864 	return 0;
865 }
866 
867 static int fc_rport_set_dev_loss_tmo(struct fc_rport *rport,
868 				     unsigned long val)
869 {
870 	struct Scsi_Host *shost = rport_to_shost(rport);
871 	struct fc_internal *i = to_fc_internal(shost->transportt);
872 
873 	if ((rport->port_state == FC_PORTSTATE_BLOCKED) ||
874 	    (rport->port_state == FC_PORTSTATE_DELETED) ||
875 	    (rport->port_state == FC_PORTSTATE_NOTPRESENT))
876 		return -EBUSY;
877 	/*
878 	 * Check for overflow; dev_loss_tmo is u32
879 	 */
880 	if (val > UINT_MAX)
881 		return -EINVAL;
882 
883 	/*
884 	 * If fast_io_fail is off we have to cap
885 	 * dev_loss_tmo at SCSI_DEVICE_BLOCK_MAX_TIMEOUT
886 	 */
887 	if (rport->fast_io_fail_tmo == -1 &&
888 	    val > SCSI_DEVICE_BLOCK_MAX_TIMEOUT)
889 		return -EINVAL;
890 
891 	i->f->set_rport_dev_loss_tmo(rport, val);
892 	return 0;
893 }
894 
895 fc_rport_show_function(dev_loss_tmo, "%d\n", 20, )
896 static ssize_t
897 store_fc_rport_dev_loss_tmo(struct device *dev, struct device_attribute *attr,
898 			    const char *buf, size_t count)
899 {
900 	struct fc_rport *rport = transport_class_to_rport(dev);
901 	unsigned long val;
902 	int rc;
903 
904 	rc = fc_str_to_dev_loss(buf, &val);
905 	if (rc)
906 		return rc;
907 
908 	rc = fc_rport_set_dev_loss_tmo(rport, val);
909 	if (rc)
910 		return rc;
911 	return count;
912 }
913 static FC_DEVICE_ATTR(rport, dev_loss_tmo, S_IRUGO | S_IWUSR,
914 		show_fc_rport_dev_loss_tmo, store_fc_rport_dev_loss_tmo);
915 
916 
917 /* Private Remote Port Attributes */
918 
919 fc_private_rport_rd_attr_cast(node_name, "0x%llx\n", 20, unsigned long long);
920 fc_private_rport_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long);
921 fc_private_rport_rd_attr(port_id, "0x%06x\n", 20);
922 
923 static ssize_t
924 show_fc_rport_roles (struct device *dev, struct device_attribute *attr,
925 		     char *buf)
926 {
927 	struct fc_rport *rport = transport_class_to_rport(dev);
928 
929 	/* identify any roles that are port_id specific */
930 	if ((rport->port_id != -1) &&
931 	    (rport->port_id & FC_WELLKNOWN_PORTID_MASK) ==
932 					FC_WELLKNOWN_PORTID_MASK) {
933 		switch (rport->port_id & FC_WELLKNOWN_ROLE_MASK) {
934 		case FC_FPORT_PORTID:
935 			return snprintf(buf, 30, "Fabric Port\n");
936 		case FC_FABCTLR_PORTID:
937 			return snprintf(buf, 30, "Fabric Controller\n");
938 		case FC_DIRSRVR_PORTID:
939 			return snprintf(buf, 30, "Directory Server\n");
940 		case FC_TIMESRVR_PORTID:
941 			return snprintf(buf, 30, "Time Server\n");
942 		case FC_MGMTSRVR_PORTID:
943 			return snprintf(buf, 30, "Management Server\n");
944 		default:
945 			return snprintf(buf, 30, "Unknown Fabric Entity\n");
946 		}
947 	} else {
948 		if (rport->roles == FC_PORT_ROLE_UNKNOWN)
949 			return snprintf(buf, 20, "unknown\n");
950 		return get_fc_port_roles_names(rport->roles, buf);
951 	}
952 }
953 static FC_DEVICE_ATTR(rport, roles, S_IRUGO,
954 		show_fc_rport_roles, NULL);
955 
956 fc_private_rport_rd_enum_attr(port_state, FC_PORTSTATE_MAX_NAMELEN);
957 fc_private_rport_rd_attr(scsi_target_id, "%d\n", 20);
958 
959 /*
960  * fast_io_fail_tmo attribute
961  */
962 static ssize_t
963 show_fc_rport_fast_io_fail_tmo (struct device *dev,
964 				struct device_attribute *attr, char *buf)
965 {
966 	struct fc_rport *rport = transport_class_to_rport(dev);
967 
968 	if (rport->fast_io_fail_tmo == -1)
969 		return snprintf(buf, 5, "off\n");
970 	return snprintf(buf, 20, "%d\n", rport->fast_io_fail_tmo);
971 }
972 
973 static ssize_t
974 store_fc_rport_fast_io_fail_tmo(struct device *dev,
975 				struct device_attribute *attr, const char *buf,
976 				size_t count)
977 {
978 	int val;
979 	char *cp;
980 	struct fc_rport *rport = transport_class_to_rport(dev);
981 
982 	if ((rport->port_state == FC_PORTSTATE_BLOCKED) ||
983 	    (rport->port_state == FC_PORTSTATE_DELETED) ||
984 	    (rport->port_state == FC_PORTSTATE_NOTPRESENT))
985 		return -EBUSY;
986 	if (strncmp(buf, "off", 3) == 0)
987 		rport->fast_io_fail_tmo = -1;
988 	else {
989 		val = simple_strtoul(buf, &cp, 0);
990 		if ((*cp && (*cp != '\n')) || (val < 0))
991 			return -EINVAL;
992 		/*
993 		 * Cap fast_io_fail by dev_loss_tmo or
994 		 * SCSI_DEVICE_BLOCK_MAX_TIMEOUT.
995 		 */
996 		if ((val >= rport->dev_loss_tmo) ||
997 		    (val > SCSI_DEVICE_BLOCK_MAX_TIMEOUT))
998 			return -EINVAL;
999 
1000 		rport->fast_io_fail_tmo = val;
1001 	}
1002 	return count;
1003 }
1004 static FC_DEVICE_ATTR(rport, fast_io_fail_tmo, S_IRUGO | S_IWUSR,
1005 	show_fc_rport_fast_io_fail_tmo, store_fc_rport_fast_io_fail_tmo);
1006 
1007 
1008 /*
1009  * FC SCSI Target Attribute Management
1010  */
1011 
1012 /*
1013  * Note: in the target show function we recognize when the remote
1014  *  port is in the hierarchy and do not allow the driver to get
1015  *  involved in sysfs functions. The driver only gets involved if
1016  *  it's the "old" style that doesn't use rports.
1017  */
1018 #define fc_starget_show_function(field, format_string, sz, cast)	\
1019 static ssize_t								\
1020 show_fc_starget_##field (struct device *dev, 				\
1021 			 struct device_attribute *attr, char *buf)	\
1022 {									\
1023 	struct scsi_target *starget = transport_class_to_starget(dev);	\
1024 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);	\
1025 	struct fc_internal *i = to_fc_internal(shost->transportt);	\
1026 	struct fc_rport *rport = starget_to_rport(starget);		\
1027 	if (rport)							\
1028 		fc_starget_##field(starget) = rport->field;		\
1029 	else if (i->f->get_starget_##field)				\
1030 		i->f->get_starget_##field(starget);			\
1031 	return snprintf(buf, sz, format_string, 			\
1032 		cast fc_starget_##field(starget)); 			\
1033 }
1034 
1035 #define fc_starget_rd_attr(field, format_string, sz)			\
1036 	fc_starget_show_function(field, format_string, sz, )		\
1037 static FC_DEVICE_ATTR(starget, field, S_IRUGO,			\
1038 			 show_fc_starget_##field, NULL)
1039 
1040 #define fc_starget_rd_attr_cast(field, format_string, sz, cast)		\
1041 	fc_starget_show_function(field, format_string, sz, (cast))	\
1042 static FC_DEVICE_ATTR(starget, field, S_IRUGO,			\
1043 			  show_fc_starget_##field, NULL)
1044 
1045 #define SETUP_STARGET_ATTRIBUTE_RD(field)				\
1046 	i->private_starget_attrs[count] = device_attr_starget_##field; \
1047 	i->private_starget_attrs[count].attr.mode = S_IRUGO;		\
1048 	i->private_starget_attrs[count].store = NULL;			\
1049 	i->starget_attrs[count] = &i->private_starget_attrs[count];	\
1050 	if (i->f->show_starget_##field)					\
1051 		count++
1052 
1053 #define SETUP_STARGET_ATTRIBUTE_RW(field)				\
1054 	i->private_starget_attrs[count] = device_attr_starget_##field; \
1055 	if (!i->f->set_starget_##field) {				\
1056 		i->private_starget_attrs[count].attr.mode = S_IRUGO;	\
1057 		i->private_starget_attrs[count].store = NULL;		\
1058 	}								\
1059 	i->starget_attrs[count] = &i->private_starget_attrs[count];	\
1060 	if (i->f->show_starget_##field)					\
1061 		count++
1062 
1063 /* The FC Transport SCSI Target Attributes: */
1064 fc_starget_rd_attr_cast(node_name, "0x%llx\n", 20, unsigned long long);
1065 fc_starget_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long);
1066 fc_starget_rd_attr(port_id, "0x%06x\n", 20);
1067 
1068 
1069 /*
1070  * FC Virtual Port Attribute Management
1071  */
1072 
1073 #define fc_vport_show_function(field, format_string, sz, cast)		\
1074 static ssize_t								\
1075 show_fc_vport_##field (struct device *dev, 				\
1076 		       struct device_attribute *attr, char *buf)	\
1077 {									\
1078 	struct fc_vport *vport = transport_class_to_vport(dev);		\
1079 	struct Scsi_Host *shost = vport_to_shost(vport);		\
1080 	struct fc_internal *i = to_fc_internal(shost->transportt);	\
1081 	if ((i->f->get_vport_##field) &&				\
1082 	    !(vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING)))	\
1083 		i->f->get_vport_##field(vport);				\
1084 	return snprintf(buf, sz, format_string, cast vport->field); 	\
1085 }
1086 
1087 #define fc_vport_store_function(field)					\
1088 static ssize_t								\
1089 store_fc_vport_##field(struct device *dev,				\
1090 		       struct device_attribute *attr,			\
1091 		       const char *buf,	size_t count)			\
1092 {									\
1093 	int val;							\
1094 	struct fc_vport *vport = transport_class_to_vport(dev);		\
1095 	struct Scsi_Host *shost = vport_to_shost(vport);		\
1096 	struct fc_internal *i = to_fc_internal(shost->transportt);	\
1097 	char *cp;							\
1098 	if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING))	\
1099 		return -EBUSY;						\
1100 	val = simple_strtoul(buf, &cp, 0);				\
1101 	if (*cp && (*cp != '\n'))					\
1102 		return -EINVAL;						\
1103 	i->f->set_vport_##field(vport, val);				\
1104 	return count;							\
1105 }
1106 
1107 #define fc_vport_store_str_function(field, slen)			\
1108 static ssize_t								\
1109 store_fc_vport_##field(struct device *dev,				\
1110 		       struct device_attribute *attr, 			\
1111 		       const char *buf,	size_t count)			\
1112 {									\
1113 	struct fc_vport *vport = transport_class_to_vport(dev);		\
1114 	struct Scsi_Host *shost = vport_to_shost(vport);		\
1115 	struct fc_internal *i = to_fc_internal(shost->transportt);	\
1116 	unsigned int cnt=count;						\
1117 									\
1118 	/* count may include a LF at end of string */			\
1119 	if (buf[cnt-1] == '\n')						\
1120 		cnt--;							\
1121 	if (cnt > ((slen) - 1))						\
1122 		return -EINVAL;						\
1123 	memcpy(vport->field, buf, cnt);					\
1124 	i->f->set_vport_##field(vport);					\
1125 	return count;							\
1126 }
1127 
1128 #define fc_vport_rd_attr(field, format_string, sz)			\
1129 	fc_vport_show_function(field, format_string, sz, )		\
1130 static FC_DEVICE_ATTR(vport, field, S_IRUGO,			\
1131 			 show_fc_vport_##field, NULL)
1132 
1133 #define fc_vport_rd_attr_cast(field, format_string, sz, cast)		\
1134 	fc_vport_show_function(field, format_string, sz, (cast))	\
1135 static FC_DEVICE_ATTR(vport, field, S_IRUGO,			\
1136 			  show_fc_vport_##field, NULL)
1137 
1138 #define fc_vport_rw_attr(field, format_string, sz)			\
1139 	fc_vport_show_function(field, format_string, sz, )		\
1140 	fc_vport_store_function(field)					\
1141 static FC_DEVICE_ATTR(vport, field, S_IRUGO | S_IWUSR,		\
1142 			show_fc_vport_##field,				\
1143 			store_fc_vport_##field)
1144 
1145 #define fc_private_vport_show_function(field, format_string, sz, cast)	\
1146 static ssize_t								\
1147 show_fc_vport_##field (struct device *dev,				\
1148 		       struct device_attribute *attr, char *buf)	\
1149 {									\
1150 	struct fc_vport *vport = transport_class_to_vport(dev);		\
1151 	return snprintf(buf, sz, format_string, cast vport->field); 	\
1152 }
1153 
1154 #define fc_private_vport_store_u32_function(field)			\
1155 static ssize_t								\
1156 store_fc_vport_##field(struct device *dev,				\
1157 		       struct device_attribute *attr,			\
1158 		       const char *buf,	size_t count)			\
1159 {									\
1160 	u32 val;							\
1161 	struct fc_vport *vport = transport_class_to_vport(dev);		\
1162 	char *cp;							\
1163 	if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING))		\
1164 		return -EBUSY;						\
1165 	val = simple_strtoul(buf, &cp, 0);				\
1166 	if (*cp && (*cp != '\n'))					\
1167 		return -EINVAL;						\
1168 	vport->field = val;						\
1169 	return count;							\
1170 }
1171 
1172 
1173 #define fc_private_vport_rd_attr(field, format_string, sz)		\
1174 	fc_private_vport_show_function(field, format_string, sz, )	\
1175 static FC_DEVICE_ATTR(vport, field, S_IRUGO,			\
1176 			 show_fc_vport_##field, NULL)
1177 
1178 #define fc_private_vport_rd_attr_cast(field, format_string, sz, cast)	\
1179 	fc_private_vport_show_function(field, format_string, sz, (cast)) \
1180 static FC_DEVICE_ATTR(vport, field, S_IRUGO,			\
1181 			  show_fc_vport_##field, NULL)
1182 
1183 #define fc_private_vport_rw_u32_attr(field, format_string, sz)		\
1184 	fc_private_vport_show_function(field, format_string, sz, )	\
1185 	fc_private_vport_store_u32_function(field)			\
1186 static FC_DEVICE_ATTR(vport, field, S_IRUGO | S_IWUSR,		\
1187 			show_fc_vport_##field,				\
1188 			store_fc_vport_##field)
1189 
1190 
1191 #define fc_private_vport_rd_enum_attr(title, maxlen)			\
1192 static ssize_t								\
1193 show_fc_vport_##title (struct device *dev,				\
1194 		       struct device_attribute *attr,			\
1195 		       char *buf)					\
1196 {									\
1197 	struct fc_vport *vport = transport_class_to_vport(dev);		\
1198 	const char *name;						\
1199 	name = get_fc_##title##_name(vport->title);			\
1200 	if (!name)							\
1201 		return -EINVAL;						\
1202 	return snprintf(buf, maxlen, "%s\n", name);			\
1203 }									\
1204 static FC_DEVICE_ATTR(vport, title, S_IRUGO,			\
1205 			show_fc_vport_##title, NULL)
1206 
1207 
1208 #define SETUP_VPORT_ATTRIBUTE_RD(field)					\
1209 	i->private_vport_attrs[count] = device_attr_vport_##field; \
1210 	i->private_vport_attrs[count].attr.mode = S_IRUGO;		\
1211 	i->private_vport_attrs[count].store = NULL;			\
1212 	i->vport_attrs[count] = &i->private_vport_attrs[count];		\
1213 	if (i->f->get_##field)						\
1214 		count++
1215 	/* NOTE: Above MACRO differs: checks function not show bit */
1216 
1217 #define SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(field)				\
1218 	i->private_vport_attrs[count] = device_attr_vport_##field; \
1219 	i->private_vport_attrs[count].attr.mode = S_IRUGO;		\
1220 	i->private_vport_attrs[count].store = NULL;			\
1221 	i->vport_attrs[count] = &i->private_vport_attrs[count];		\
1222 	count++
1223 
1224 #define SETUP_VPORT_ATTRIBUTE_WR(field)					\
1225 	i->private_vport_attrs[count] = device_attr_vport_##field; \
1226 	i->vport_attrs[count] = &i->private_vport_attrs[count];		\
1227 	if (i->f->field)						\
1228 		count++
1229 	/* NOTE: Above MACRO differs: checks function */
1230 
1231 #define SETUP_VPORT_ATTRIBUTE_RW(field)					\
1232 	i->private_vport_attrs[count] = device_attr_vport_##field; \
1233 	if (!i->f->set_vport_##field) {					\
1234 		i->private_vport_attrs[count].attr.mode = S_IRUGO;	\
1235 		i->private_vport_attrs[count].store = NULL;		\
1236 	}								\
1237 	i->vport_attrs[count] = &i->private_vport_attrs[count];		\
1238 	count++
1239 	/* NOTE: Above MACRO differs: does not check show bit */
1240 
1241 #define SETUP_PRIVATE_VPORT_ATTRIBUTE_RW(field)				\
1242 {									\
1243 	i->private_vport_attrs[count] = device_attr_vport_##field; \
1244 	i->vport_attrs[count] = &i->private_vport_attrs[count];		\
1245 	count++;							\
1246 }
1247 
1248 
1249 /* The FC Transport Virtual Port Attributes: */
1250 
1251 /* Fixed Virtual Port Attributes */
1252 
1253 /* Dynamic Virtual Port Attributes */
1254 
1255 /* Private Virtual Port Attributes */
1256 
1257 fc_private_vport_rd_enum_attr(vport_state, FC_VPORTSTATE_MAX_NAMELEN);
1258 fc_private_vport_rd_enum_attr(vport_last_state, FC_VPORTSTATE_MAX_NAMELEN);
1259 fc_private_vport_rd_attr_cast(node_name, "0x%llx\n", 20, unsigned long long);
1260 fc_private_vport_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long);
1261 
1262 static ssize_t
1263 show_fc_vport_roles (struct device *dev, struct device_attribute *attr,
1264 		     char *buf)
1265 {
1266 	struct fc_vport *vport = transport_class_to_vport(dev);
1267 
1268 	if (vport->roles == FC_PORT_ROLE_UNKNOWN)
1269 		return snprintf(buf, 20, "unknown\n");
1270 	return get_fc_port_roles_names(vport->roles, buf);
1271 }
1272 static FC_DEVICE_ATTR(vport, roles, S_IRUGO, show_fc_vport_roles, NULL);
1273 
1274 fc_private_vport_rd_enum_attr(vport_type, FC_PORTTYPE_MAX_NAMELEN);
1275 
1276 fc_private_vport_show_function(symbolic_name, "%s\n",
1277 		FC_VPORT_SYMBOLIC_NAMELEN + 1, )
1278 fc_vport_store_str_function(symbolic_name, FC_VPORT_SYMBOLIC_NAMELEN)
1279 static FC_DEVICE_ATTR(vport, symbolic_name, S_IRUGO | S_IWUSR,
1280 		show_fc_vport_symbolic_name, store_fc_vport_symbolic_name);
1281 
1282 static ssize_t
1283 store_fc_vport_delete(struct device *dev, struct device_attribute *attr,
1284 		      const char *buf, size_t count)
1285 {
1286 	struct fc_vport *vport = transport_class_to_vport(dev);
1287 	struct Scsi_Host *shost = vport_to_shost(vport);
1288 	unsigned long flags;
1289 
1290 	spin_lock_irqsave(shost->host_lock, flags);
1291 	if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING | FC_VPORT_DELETING)) {
1292 		spin_unlock_irqrestore(shost->host_lock, flags);
1293 		return -EBUSY;
1294 	}
1295 	vport->flags |= FC_VPORT_DELETING;
1296 	spin_unlock_irqrestore(shost->host_lock, flags);
1297 
1298 	fc_queue_work(shost, &vport->vport_delete_work);
1299 	return count;
1300 }
1301 static FC_DEVICE_ATTR(vport, vport_delete, S_IWUSR,
1302 			NULL, store_fc_vport_delete);
1303 
1304 
1305 /*
1306  * Enable/Disable vport
1307  *  Write "1" to disable, write "0" to enable
1308  */
1309 static ssize_t
1310 store_fc_vport_disable(struct device *dev, struct device_attribute *attr,
1311 		       const char *buf,
1312 			   size_t count)
1313 {
1314 	struct fc_vport *vport = transport_class_to_vport(dev);
1315 	struct Scsi_Host *shost = vport_to_shost(vport);
1316 	struct fc_internal *i = to_fc_internal(shost->transportt);
1317 	int stat;
1318 
1319 	if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING))
1320 		return -EBUSY;
1321 
1322 	if (*buf == '0') {
1323 		if (vport->vport_state != FC_VPORT_DISABLED)
1324 			return -EALREADY;
1325 	} else if (*buf == '1') {
1326 		if (vport->vport_state == FC_VPORT_DISABLED)
1327 			return -EALREADY;
1328 	} else
1329 		return -EINVAL;
1330 
1331 	stat = i->f->vport_disable(vport, ((*buf == '0') ? false : true));
1332 	return stat ? stat : count;
1333 }
1334 static FC_DEVICE_ATTR(vport, vport_disable, S_IWUSR,
1335 			NULL, store_fc_vport_disable);
1336 
1337 
1338 /*
1339  * Host Attribute Management
1340  */
1341 
1342 #define fc_host_show_function(field, format_string, sz, cast)		\
1343 static ssize_t								\
1344 show_fc_host_##field (struct device *dev,				\
1345 		      struct device_attribute *attr, char *buf)		\
1346 {									\
1347 	struct Scsi_Host *shost = transport_class_to_shost(dev);	\
1348 	struct fc_internal *i = to_fc_internal(shost->transportt);	\
1349 	if (i->f->get_host_##field)					\
1350 		i->f->get_host_##field(shost);				\
1351 	return snprintf(buf, sz, format_string, cast fc_host_##field(shost)); \
1352 }
1353 
1354 #define fc_host_store_function(field)					\
1355 static ssize_t								\
1356 store_fc_host_##field(struct device *dev, 				\
1357 		      struct device_attribute *attr,			\
1358 		      const char *buf,	size_t count)			\
1359 {									\
1360 	int val;							\
1361 	struct Scsi_Host *shost = transport_class_to_shost(dev);	\
1362 	struct fc_internal *i = to_fc_internal(shost->transportt);	\
1363 	char *cp;							\
1364 									\
1365 	val = simple_strtoul(buf, &cp, 0);				\
1366 	if (*cp && (*cp != '\n'))					\
1367 		return -EINVAL;						\
1368 	i->f->set_host_##field(shost, val);				\
1369 	return count;							\
1370 }
1371 
1372 #define fc_host_store_str_function(field, slen)				\
1373 static ssize_t								\
1374 store_fc_host_##field(struct device *dev,				\
1375 		      struct device_attribute *attr,			\
1376 		      const char *buf, size_t count)			\
1377 {									\
1378 	struct Scsi_Host *shost = transport_class_to_shost(dev);	\
1379 	struct fc_internal *i = to_fc_internal(shost->transportt);	\
1380 	unsigned int cnt=count;						\
1381 									\
1382 	/* count may include a LF at end of string */			\
1383 	if (buf[cnt-1] == '\n')						\
1384 		cnt--;							\
1385 	if (cnt > ((slen) - 1))						\
1386 		return -EINVAL;						\
1387 	memcpy(fc_host_##field(shost), buf, cnt);			\
1388 	i->f->set_host_##field(shost);					\
1389 	return count;							\
1390 }
1391 
1392 #define fc_host_rd_attr(field, format_string, sz)			\
1393 	fc_host_show_function(field, format_string, sz, )		\
1394 static FC_DEVICE_ATTR(host, field, S_IRUGO,			\
1395 			 show_fc_host_##field, NULL)
1396 
1397 #define fc_host_rd_attr_cast(field, format_string, sz, cast)		\
1398 	fc_host_show_function(field, format_string, sz, (cast))		\
1399 static FC_DEVICE_ATTR(host, field, S_IRUGO,			\
1400 			  show_fc_host_##field, NULL)
1401 
1402 #define fc_host_rw_attr(field, format_string, sz)			\
1403 	fc_host_show_function(field, format_string, sz, )		\
1404 	fc_host_store_function(field)					\
1405 static FC_DEVICE_ATTR(host, field, S_IRUGO | S_IWUSR,		\
1406 			show_fc_host_##field,				\
1407 			store_fc_host_##field)
1408 
1409 #define fc_host_rd_enum_attr(title, maxlen)				\
1410 static ssize_t								\
1411 show_fc_host_##title (struct device *dev,				\
1412 		      struct device_attribute *attr, char *buf)		\
1413 {									\
1414 	struct Scsi_Host *shost = transport_class_to_shost(dev);	\
1415 	struct fc_internal *i = to_fc_internal(shost->transportt);	\
1416 	const char *name;						\
1417 	if (i->f->get_host_##title)					\
1418 		i->f->get_host_##title(shost);				\
1419 	name = get_fc_##title##_name(fc_host_##title(shost));		\
1420 	if (!name)							\
1421 		return -EINVAL;						\
1422 	return snprintf(buf, maxlen, "%s\n", name);			\
1423 }									\
1424 static FC_DEVICE_ATTR(host, title, S_IRUGO, show_fc_host_##title, NULL)
1425 
1426 #define SETUP_HOST_ATTRIBUTE_RD(field)					\
1427 	i->private_host_attrs[count] = device_attr_host_##field;	\
1428 	i->private_host_attrs[count].attr.mode = S_IRUGO;		\
1429 	i->private_host_attrs[count].store = NULL;			\
1430 	i->host_attrs[count] = &i->private_host_attrs[count];		\
1431 	if (i->f->show_host_##field)					\
1432 		count++
1433 
1434 #define SETUP_HOST_ATTRIBUTE_RD_NS(field)				\
1435 	i->private_host_attrs[count] = device_attr_host_##field;	\
1436 	i->private_host_attrs[count].attr.mode = S_IRUGO;		\
1437 	i->private_host_attrs[count].store = NULL;			\
1438 	i->host_attrs[count] = &i->private_host_attrs[count];		\
1439 	count++
1440 
1441 #define SETUP_HOST_ATTRIBUTE_RW(field)					\
1442 	i->private_host_attrs[count] = device_attr_host_##field;	\
1443 	if (!i->f->set_host_##field) {					\
1444 		i->private_host_attrs[count].attr.mode = S_IRUGO;	\
1445 		i->private_host_attrs[count].store = NULL;		\
1446 	}								\
1447 	i->host_attrs[count] = &i->private_host_attrs[count];		\
1448 	if (i->f->show_host_##field)					\
1449 		count++
1450 
1451 
1452 #define fc_private_host_show_function(field, format_string, sz, cast)	\
1453 static ssize_t								\
1454 show_fc_host_##field (struct device *dev,				\
1455 		      struct device_attribute *attr, char *buf)		\
1456 {									\
1457 	struct Scsi_Host *shost = transport_class_to_shost(dev);	\
1458 	return snprintf(buf, sz, format_string, cast fc_host_##field(shost)); \
1459 }
1460 
1461 #define fc_private_host_rd_attr(field, format_string, sz)		\
1462 	fc_private_host_show_function(field, format_string, sz, )	\
1463 static FC_DEVICE_ATTR(host, field, S_IRUGO,			\
1464 			 show_fc_host_##field, NULL)
1465 
1466 #define fc_private_host_rd_attr_cast(field, format_string, sz, cast)	\
1467 	fc_private_host_show_function(field, format_string, sz, (cast)) \
1468 static FC_DEVICE_ATTR(host, field, S_IRUGO,			\
1469 			  show_fc_host_##field, NULL)
1470 
1471 #define SETUP_PRIVATE_HOST_ATTRIBUTE_RD(field)			\
1472 	i->private_host_attrs[count] = device_attr_host_##field;	\
1473 	i->private_host_attrs[count].attr.mode = S_IRUGO;		\
1474 	i->private_host_attrs[count].store = NULL;			\
1475 	i->host_attrs[count] = &i->private_host_attrs[count];		\
1476 	count++
1477 
1478 #define SETUP_PRIVATE_HOST_ATTRIBUTE_RW(field)			\
1479 {									\
1480 	i->private_host_attrs[count] = device_attr_host_##field;	\
1481 	i->host_attrs[count] = &i->private_host_attrs[count];		\
1482 	count++;							\
1483 }
1484 
1485 
1486 /* Fixed Host Attributes */
1487 
1488 static ssize_t
1489 show_fc_host_supported_classes (struct device *dev,
1490 			        struct device_attribute *attr, char *buf)
1491 {
1492 	struct Scsi_Host *shost = transport_class_to_shost(dev);
1493 
1494 	if (fc_host_supported_classes(shost) == FC_COS_UNSPECIFIED)
1495 		return snprintf(buf, 20, "unspecified\n");
1496 
1497 	return get_fc_cos_names(fc_host_supported_classes(shost), buf);
1498 }
1499 static FC_DEVICE_ATTR(host, supported_classes, S_IRUGO,
1500 		show_fc_host_supported_classes, NULL);
1501 
1502 static ssize_t
1503 show_fc_host_supported_fc4s (struct device *dev,
1504 			     struct device_attribute *attr, char *buf)
1505 {
1506 	struct Scsi_Host *shost = transport_class_to_shost(dev);
1507 	return (ssize_t)show_fc_fc4s(buf, fc_host_supported_fc4s(shost));
1508 }
1509 static FC_DEVICE_ATTR(host, supported_fc4s, S_IRUGO,
1510 		show_fc_host_supported_fc4s, NULL);
1511 
1512 static ssize_t
1513 show_fc_host_supported_speeds (struct device *dev,
1514 			       struct device_attribute *attr, char *buf)
1515 {
1516 	struct Scsi_Host *shost = transport_class_to_shost(dev);
1517 
1518 	if (fc_host_supported_speeds(shost) == FC_PORTSPEED_UNKNOWN)
1519 		return snprintf(buf, 20, "unknown\n");
1520 
1521 	return get_fc_port_speed_names(fc_host_supported_speeds(shost), buf);
1522 }
1523 static FC_DEVICE_ATTR(host, supported_speeds, S_IRUGO,
1524 		show_fc_host_supported_speeds, NULL);
1525 
1526 
1527 fc_private_host_rd_attr_cast(node_name, "0x%llx\n", 20, unsigned long long);
1528 fc_private_host_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long);
1529 fc_private_host_rd_attr_cast(permanent_port_name, "0x%llx\n", 20,
1530 			     unsigned long long);
1531 fc_private_host_rd_attr(maxframe_size, "%u bytes\n", 20);
1532 fc_private_host_rd_attr(max_npiv_vports, "%u\n", 20);
1533 fc_private_host_rd_attr(serial_number, "%s\n", (FC_SERIAL_NUMBER_SIZE +1));
1534 fc_private_host_rd_attr(manufacturer, "%s\n", FC_SERIAL_NUMBER_SIZE + 1);
1535 fc_private_host_rd_attr(model, "%s\n", FC_SYMBOLIC_NAME_SIZE + 1);
1536 fc_private_host_rd_attr(model_description, "%s\n", FC_SYMBOLIC_NAME_SIZE + 1);
1537 fc_private_host_rd_attr(hardware_version, "%s\n", FC_VERSION_STRING_SIZE + 1);
1538 fc_private_host_rd_attr(driver_version, "%s\n", FC_VERSION_STRING_SIZE + 1);
1539 fc_private_host_rd_attr(firmware_version, "%s\n", FC_VERSION_STRING_SIZE + 1);
1540 fc_private_host_rd_attr(optionrom_version, "%s\n", FC_VERSION_STRING_SIZE + 1);
1541 
1542 
1543 /* Dynamic Host Attributes */
1544 
1545 static ssize_t
1546 show_fc_host_active_fc4s (struct device *dev,
1547 			  struct device_attribute *attr, char *buf)
1548 {
1549 	struct Scsi_Host *shost = transport_class_to_shost(dev);
1550 	struct fc_internal *i = to_fc_internal(shost->transportt);
1551 
1552 	if (i->f->get_host_active_fc4s)
1553 		i->f->get_host_active_fc4s(shost);
1554 
1555 	return (ssize_t)show_fc_fc4s(buf, fc_host_active_fc4s(shost));
1556 }
1557 static FC_DEVICE_ATTR(host, active_fc4s, S_IRUGO,
1558 		show_fc_host_active_fc4s, NULL);
1559 
1560 static ssize_t
1561 show_fc_host_speed (struct device *dev,
1562 		    struct device_attribute *attr, char *buf)
1563 {
1564 	struct Scsi_Host *shost = transport_class_to_shost(dev);
1565 	struct fc_internal *i = to_fc_internal(shost->transportt);
1566 
1567 	if (i->f->get_host_speed)
1568 		i->f->get_host_speed(shost);
1569 
1570 	if (fc_host_speed(shost) == FC_PORTSPEED_UNKNOWN)
1571 		return snprintf(buf, 20, "unknown\n");
1572 
1573 	return get_fc_port_speed_names(fc_host_speed(shost), buf);
1574 }
1575 static FC_DEVICE_ATTR(host, speed, S_IRUGO,
1576 		show_fc_host_speed, NULL);
1577 
1578 
1579 fc_host_rd_attr(port_id, "0x%06x\n", 20);
1580 fc_host_rd_enum_attr(port_type, FC_PORTTYPE_MAX_NAMELEN);
1581 fc_host_rd_enum_attr(port_state, FC_PORTSTATE_MAX_NAMELEN);
1582 fc_host_rd_attr_cast(fabric_name, "0x%llx\n", 20, unsigned long long);
1583 fc_host_rd_attr(symbolic_name, "%s\n", FC_SYMBOLIC_NAME_SIZE + 1);
1584 
1585 fc_private_host_show_function(system_hostname, "%s\n",
1586 		FC_SYMBOLIC_NAME_SIZE + 1, )
1587 fc_host_store_str_function(system_hostname, FC_SYMBOLIC_NAME_SIZE)
1588 static FC_DEVICE_ATTR(host, system_hostname, S_IRUGO | S_IWUSR,
1589 		show_fc_host_system_hostname, store_fc_host_system_hostname);
1590 
1591 
1592 /* Private Host Attributes */
1593 
1594 static ssize_t
1595 show_fc_private_host_tgtid_bind_type(struct device *dev,
1596 				     struct device_attribute *attr, char *buf)
1597 {
1598 	struct Scsi_Host *shost = transport_class_to_shost(dev);
1599 	const char *name;
1600 
1601 	name = get_fc_tgtid_bind_type_name(fc_host_tgtid_bind_type(shost));
1602 	if (!name)
1603 		return -EINVAL;
1604 	return snprintf(buf, FC_BINDTYPE_MAX_NAMELEN, "%s\n", name);
1605 }
1606 
1607 #define get_list_head_entry(pos, head, member) 		\
1608 	pos = list_entry((head)->next, typeof(*pos), member)
1609 
1610 static ssize_t
1611 store_fc_private_host_tgtid_bind_type(struct device *dev,
1612 	struct device_attribute *attr, const char *buf, size_t count)
1613 {
1614 	struct Scsi_Host *shost = transport_class_to_shost(dev);
1615 	struct fc_rport *rport;
1616  	enum fc_tgtid_binding_type val;
1617 	unsigned long flags;
1618 
1619 	if (get_fc_tgtid_bind_type_match(buf, &val))
1620 		return -EINVAL;
1621 
1622 	/* if changing bind type, purge all unused consistent bindings */
1623 	if (val != fc_host_tgtid_bind_type(shost)) {
1624 		spin_lock_irqsave(shost->host_lock, flags);
1625 		while (!list_empty(&fc_host_rport_bindings(shost))) {
1626 			get_list_head_entry(rport,
1627 				&fc_host_rport_bindings(shost), peers);
1628 			list_del(&rport->peers);
1629 			rport->port_state = FC_PORTSTATE_DELETED;
1630 			fc_queue_work(shost, &rport->rport_delete_work);
1631 		}
1632 		spin_unlock_irqrestore(shost->host_lock, flags);
1633 	}
1634 
1635 	fc_host_tgtid_bind_type(shost) = val;
1636 	return count;
1637 }
1638 
1639 static FC_DEVICE_ATTR(host, tgtid_bind_type, S_IRUGO | S_IWUSR,
1640 			show_fc_private_host_tgtid_bind_type,
1641 			store_fc_private_host_tgtid_bind_type);
1642 
1643 static ssize_t
1644 store_fc_private_host_issue_lip(struct device *dev,
1645 	struct device_attribute *attr, const char *buf, size_t count)
1646 {
1647 	struct Scsi_Host *shost = transport_class_to_shost(dev);
1648 	struct fc_internal *i = to_fc_internal(shost->transportt);
1649 	int ret;
1650 
1651 	/* ignore any data value written to the attribute */
1652 	if (i->f->issue_fc_host_lip) {
1653 		ret = i->f->issue_fc_host_lip(shost);
1654 		return ret ? ret: count;
1655 	}
1656 
1657 	return -ENOENT;
1658 }
1659 
1660 static FC_DEVICE_ATTR(host, issue_lip, S_IWUSR, NULL,
1661 			store_fc_private_host_issue_lip);
1662 
1663 static ssize_t
1664 store_fc_private_host_dev_loss_tmo(struct device *dev,
1665 				   struct device_attribute *attr,
1666 				   const char *buf, size_t count)
1667 {
1668 	struct Scsi_Host *shost = transport_class_to_shost(dev);
1669 	struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
1670 	struct fc_rport *rport;
1671 	unsigned long val, flags;
1672 	int rc;
1673 
1674 	rc = fc_str_to_dev_loss(buf, &val);
1675 	if (rc)
1676 		return rc;
1677 
1678 	fc_host_dev_loss_tmo(shost) = val;
1679 	spin_lock_irqsave(shost->host_lock, flags);
1680 	list_for_each_entry(rport, &fc_host->rports, peers)
1681 		fc_rport_set_dev_loss_tmo(rport, val);
1682 	spin_unlock_irqrestore(shost->host_lock, flags);
1683 	return count;
1684 }
1685 
1686 fc_private_host_show_function(dev_loss_tmo, "%d\n", 20, );
1687 static FC_DEVICE_ATTR(host, dev_loss_tmo, S_IRUGO | S_IWUSR,
1688 		      show_fc_host_dev_loss_tmo,
1689 		      store_fc_private_host_dev_loss_tmo);
1690 
1691 fc_private_host_rd_attr(npiv_vports_inuse, "%u\n", 20);
1692 
1693 /*
1694  * Host Statistics Management
1695  */
1696 
1697 /* Show a given attribute in the statistics group */
1698 static ssize_t
1699 fc_stat_show(const struct device *dev, char *buf, unsigned long offset)
1700 {
1701 	struct Scsi_Host *shost = transport_class_to_shost(dev);
1702 	struct fc_internal *i = to_fc_internal(shost->transportt);
1703 	struct fc_host_statistics *stats;
1704 	ssize_t ret = -ENOENT;
1705 
1706 	if (offset > sizeof(struct fc_host_statistics) ||
1707 	    offset % sizeof(u64) != 0)
1708 		WARN_ON(1);
1709 
1710 	if (i->f->get_fc_host_stats) {
1711 		stats = (i->f->get_fc_host_stats)(shost);
1712 		if (stats)
1713 			ret = snprintf(buf, 20, "0x%llx\n",
1714 			      (unsigned long long)*(u64 *)(((u8 *) stats) + offset));
1715 	}
1716 	return ret;
1717 }
1718 
1719 
1720 /* generate a read-only statistics attribute */
1721 #define fc_host_statistic(name)						\
1722 static ssize_t show_fcstat_##name(struct device *cd,			\
1723 				  struct device_attribute *attr,	\
1724 				  char *buf)				\
1725 {									\
1726 	return fc_stat_show(cd, buf, 					\
1727 			    offsetof(struct fc_host_statistics, name));	\
1728 }									\
1729 static FC_DEVICE_ATTR(host, name, S_IRUGO, show_fcstat_##name, NULL)
1730 
1731 fc_host_statistic(seconds_since_last_reset);
1732 fc_host_statistic(tx_frames);
1733 fc_host_statistic(tx_words);
1734 fc_host_statistic(rx_frames);
1735 fc_host_statistic(rx_words);
1736 fc_host_statistic(lip_count);
1737 fc_host_statistic(nos_count);
1738 fc_host_statistic(error_frames);
1739 fc_host_statistic(dumped_frames);
1740 fc_host_statistic(link_failure_count);
1741 fc_host_statistic(loss_of_sync_count);
1742 fc_host_statistic(loss_of_signal_count);
1743 fc_host_statistic(prim_seq_protocol_err_count);
1744 fc_host_statistic(invalid_tx_word_count);
1745 fc_host_statistic(invalid_crc_count);
1746 fc_host_statistic(fcp_input_requests);
1747 fc_host_statistic(fcp_output_requests);
1748 fc_host_statistic(fcp_control_requests);
1749 fc_host_statistic(fcp_input_megabytes);
1750 fc_host_statistic(fcp_output_megabytes);
1751 fc_host_statistic(fcp_packet_alloc_failures);
1752 fc_host_statistic(fcp_packet_aborts);
1753 fc_host_statistic(fcp_frame_alloc_failures);
1754 fc_host_statistic(fc_no_free_exch);
1755 fc_host_statistic(fc_no_free_exch_xid);
1756 fc_host_statistic(fc_xid_not_found);
1757 fc_host_statistic(fc_xid_busy);
1758 fc_host_statistic(fc_seq_not_found);
1759 fc_host_statistic(fc_non_bls_resp);
1760 
1761 static ssize_t
1762 fc_reset_statistics(struct device *dev, struct device_attribute *attr,
1763 		    const char *buf, size_t count)
1764 {
1765 	struct Scsi_Host *shost = transport_class_to_shost(dev);
1766 	struct fc_internal *i = to_fc_internal(shost->transportt);
1767 
1768 	/* ignore any data value written to the attribute */
1769 	if (i->f->reset_fc_host_stats) {
1770 		i->f->reset_fc_host_stats(shost);
1771 		return count;
1772 	}
1773 
1774 	return -ENOENT;
1775 }
1776 static FC_DEVICE_ATTR(host, reset_statistics, S_IWUSR, NULL,
1777 				fc_reset_statistics);
1778 
1779 static struct attribute *fc_statistics_attrs[] = {
1780 	&device_attr_host_seconds_since_last_reset.attr,
1781 	&device_attr_host_tx_frames.attr,
1782 	&device_attr_host_tx_words.attr,
1783 	&device_attr_host_rx_frames.attr,
1784 	&device_attr_host_rx_words.attr,
1785 	&device_attr_host_lip_count.attr,
1786 	&device_attr_host_nos_count.attr,
1787 	&device_attr_host_error_frames.attr,
1788 	&device_attr_host_dumped_frames.attr,
1789 	&device_attr_host_link_failure_count.attr,
1790 	&device_attr_host_loss_of_sync_count.attr,
1791 	&device_attr_host_loss_of_signal_count.attr,
1792 	&device_attr_host_prim_seq_protocol_err_count.attr,
1793 	&device_attr_host_invalid_tx_word_count.attr,
1794 	&device_attr_host_invalid_crc_count.attr,
1795 	&device_attr_host_fcp_input_requests.attr,
1796 	&device_attr_host_fcp_output_requests.attr,
1797 	&device_attr_host_fcp_control_requests.attr,
1798 	&device_attr_host_fcp_input_megabytes.attr,
1799 	&device_attr_host_fcp_output_megabytes.attr,
1800 	&device_attr_host_fcp_packet_alloc_failures.attr,
1801 	&device_attr_host_fcp_packet_aborts.attr,
1802 	&device_attr_host_fcp_frame_alloc_failures.attr,
1803 	&device_attr_host_fc_no_free_exch.attr,
1804 	&device_attr_host_fc_no_free_exch_xid.attr,
1805 	&device_attr_host_fc_xid_not_found.attr,
1806 	&device_attr_host_fc_xid_busy.attr,
1807 	&device_attr_host_fc_seq_not_found.attr,
1808 	&device_attr_host_fc_non_bls_resp.attr,
1809 	&device_attr_host_reset_statistics.attr,
1810 	NULL
1811 };
1812 
1813 static struct attribute_group fc_statistics_group = {
1814 	.name = "statistics",
1815 	.attrs = fc_statistics_attrs,
1816 };
1817 
1818 
1819 /* Host Vport Attributes */
1820 
1821 static int
1822 fc_parse_wwn(const char *ns, u64 *nm)
1823 {
1824 	unsigned int i, j;
1825 	u8 wwn[8];
1826 
1827 	memset(wwn, 0, sizeof(wwn));
1828 
1829 	/* Validate and store the new name */
1830 	for (i=0, j=0; i < 16; i++) {
1831 		int value;
1832 
1833 		value = hex_to_bin(*ns++);
1834 		if (value >= 0)
1835 			j = (j << 4) | value;
1836 		else
1837 			return -EINVAL;
1838 		if (i % 2) {
1839 			wwn[i/2] = j & 0xff;
1840 			j = 0;
1841 		}
1842 	}
1843 
1844 	*nm = wwn_to_u64(wwn);
1845 
1846 	return 0;
1847 }
1848 
1849 
1850 /*
1851  * "Short-cut" sysfs variable to create a new vport on a FC Host.
1852  * Input is a string of the form "<WWPN>:<WWNN>". Other attributes
1853  * will default to a NPIV-based FCP_Initiator; The WWNs are specified
1854  * as hex characters, and may *not* contain any prefixes (e.g. 0x, x, etc)
1855  */
1856 static ssize_t
1857 store_fc_host_vport_create(struct device *dev, struct device_attribute *attr,
1858 			   const char *buf, size_t count)
1859 {
1860 	struct Scsi_Host *shost = transport_class_to_shost(dev);
1861 	struct fc_vport_identifiers vid;
1862 	struct fc_vport *vport;
1863 	unsigned int cnt=count;
1864 	int stat;
1865 
1866 	memset(&vid, 0, sizeof(vid));
1867 
1868 	/* count may include a LF at end of string */
1869 	if (buf[cnt-1] == '\n')
1870 		cnt--;
1871 
1872 	/* validate we have enough characters for WWPN */
1873 	if ((cnt != (16+1+16)) || (buf[16] != ':'))
1874 		return -EINVAL;
1875 
1876 	stat = fc_parse_wwn(&buf[0], &vid.port_name);
1877 	if (stat)
1878 		return stat;
1879 
1880 	stat = fc_parse_wwn(&buf[17], &vid.node_name);
1881 	if (stat)
1882 		return stat;
1883 
1884 	vid.roles = FC_PORT_ROLE_FCP_INITIATOR;
1885 	vid.vport_type = FC_PORTTYPE_NPIV;
1886 	/* vid.symbolic_name is already zero/NULL's */
1887 	vid.disable = false;		/* always enabled */
1888 
1889 	/* we only allow support on Channel 0 !!! */
1890 	stat = fc_vport_setup(shost, 0, &shost->shost_gendev, &vid, &vport);
1891 	return stat ? stat : count;
1892 }
1893 static FC_DEVICE_ATTR(host, vport_create, S_IWUSR, NULL,
1894 			store_fc_host_vport_create);
1895 
1896 
1897 /*
1898  * "Short-cut" sysfs variable to delete a vport on a FC Host.
1899  * Vport is identified by a string containing "<WWPN>:<WWNN>".
1900  * The WWNs are specified as hex characters, and may *not* contain
1901  * any prefixes (e.g. 0x, x, etc)
1902  */
1903 static ssize_t
1904 store_fc_host_vport_delete(struct device *dev, struct device_attribute *attr,
1905 			   const char *buf, size_t count)
1906 {
1907 	struct Scsi_Host *shost = transport_class_to_shost(dev);
1908 	struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
1909 	struct fc_vport *vport;
1910 	u64 wwpn, wwnn;
1911 	unsigned long flags;
1912 	unsigned int cnt=count;
1913 	int stat, match;
1914 
1915 	/* count may include a LF at end of string */
1916 	if (buf[cnt-1] == '\n')
1917 		cnt--;
1918 
1919 	/* validate we have enough characters for WWPN */
1920 	if ((cnt != (16+1+16)) || (buf[16] != ':'))
1921 		return -EINVAL;
1922 
1923 	stat = fc_parse_wwn(&buf[0], &wwpn);
1924 	if (stat)
1925 		return stat;
1926 
1927 	stat = fc_parse_wwn(&buf[17], &wwnn);
1928 	if (stat)
1929 		return stat;
1930 
1931 	spin_lock_irqsave(shost->host_lock, flags);
1932 	match = 0;
1933 	/* we only allow support on Channel 0 !!! */
1934 	list_for_each_entry(vport, &fc_host->vports, peers) {
1935 		if ((vport->channel == 0) &&
1936 		    (vport->port_name == wwpn) && (vport->node_name == wwnn)) {
1937 			if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING))
1938 				break;
1939 			vport->flags |= FC_VPORT_DELETING;
1940 			match = 1;
1941 			break;
1942 		}
1943 	}
1944 	spin_unlock_irqrestore(shost->host_lock, flags);
1945 
1946 	if (!match)
1947 		return -ENODEV;
1948 
1949 	stat = fc_vport_terminate(vport);
1950 	return stat ? stat : count;
1951 }
1952 static FC_DEVICE_ATTR(host, vport_delete, S_IWUSR, NULL,
1953 			store_fc_host_vport_delete);
1954 
1955 
1956 static int fc_host_match(struct attribute_container *cont,
1957 			  struct device *dev)
1958 {
1959 	struct Scsi_Host *shost;
1960 	struct fc_internal *i;
1961 
1962 	if (!scsi_is_host_device(dev))
1963 		return 0;
1964 
1965 	shost = dev_to_shost(dev);
1966 	if (!shost->transportt  || shost->transportt->host_attrs.ac.class
1967 	    != &fc_host_class.class)
1968 		return 0;
1969 
1970 	i = to_fc_internal(shost->transportt);
1971 
1972 	return &i->t.host_attrs.ac == cont;
1973 }
1974 
1975 static int fc_target_match(struct attribute_container *cont,
1976 			    struct device *dev)
1977 {
1978 	struct Scsi_Host *shost;
1979 	struct fc_internal *i;
1980 
1981 	if (!scsi_is_target_device(dev))
1982 		return 0;
1983 
1984 	shost = dev_to_shost(dev->parent);
1985 	if (!shost->transportt  || shost->transportt->host_attrs.ac.class
1986 	    != &fc_host_class.class)
1987 		return 0;
1988 
1989 	i = to_fc_internal(shost->transportt);
1990 
1991 	return &i->t.target_attrs.ac == cont;
1992 }
1993 
1994 static void fc_rport_dev_release(struct device *dev)
1995 {
1996 	struct fc_rport *rport = dev_to_rport(dev);
1997 	put_device(dev->parent);
1998 	kfree(rport);
1999 }
2000 
2001 int scsi_is_fc_rport(const struct device *dev)
2002 {
2003 	return dev->release == fc_rport_dev_release;
2004 }
2005 EXPORT_SYMBOL(scsi_is_fc_rport);
2006 
2007 static int fc_rport_match(struct attribute_container *cont,
2008 			    struct device *dev)
2009 {
2010 	struct Scsi_Host *shost;
2011 	struct fc_internal *i;
2012 
2013 	if (!scsi_is_fc_rport(dev))
2014 		return 0;
2015 
2016 	shost = dev_to_shost(dev->parent);
2017 	if (!shost->transportt  || shost->transportt->host_attrs.ac.class
2018 	    != &fc_host_class.class)
2019 		return 0;
2020 
2021 	i = to_fc_internal(shost->transportt);
2022 
2023 	return &i->rport_attr_cont.ac == cont;
2024 }
2025 
2026 
2027 static void fc_vport_dev_release(struct device *dev)
2028 {
2029 	struct fc_vport *vport = dev_to_vport(dev);
2030 	put_device(dev->parent);		/* release kobj parent */
2031 	kfree(vport);
2032 }
2033 
2034 static int scsi_is_fc_vport(const struct device *dev)
2035 {
2036 	return dev->release == fc_vport_dev_release;
2037 }
2038 
2039 static int fc_vport_match(struct attribute_container *cont,
2040 			    struct device *dev)
2041 {
2042 	struct fc_vport *vport;
2043 	struct Scsi_Host *shost;
2044 	struct fc_internal *i;
2045 
2046 	if (!scsi_is_fc_vport(dev))
2047 		return 0;
2048 	vport = dev_to_vport(dev);
2049 
2050 	shost = vport_to_shost(vport);
2051 	if (!shost->transportt  || shost->transportt->host_attrs.ac.class
2052 	    != &fc_host_class.class)
2053 		return 0;
2054 
2055 	i = to_fc_internal(shost->transportt);
2056 	return &i->vport_attr_cont.ac == cont;
2057 }
2058 
2059 
2060 /**
2061  * fc_eh_timed_out - FC Transport I/O timeout intercept handler
2062  * @scmd:	The SCSI command which timed out
2063  *
2064  * This routine protects against error handlers getting invoked while a
2065  * rport is in a blocked state, typically due to a temporarily loss of
2066  * connectivity. If the error handlers are allowed to proceed, requests
2067  * to abort i/o, reset the target, etc will likely fail as there is no way
2068  * to communicate with the device to perform the requested function. These
2069  * failures may result in the midlayer taking the device offline, requiring
2070  * manual intervention to restore operation.
2071  *
2072  * This routine, called whenever an i/o times out, validates the state of
2073  * the underlying rport. If the rport is blocked, it returns
2074  * EH_RESET_TIMER, which will continue to reschedule the timeout.
2075  * Eventually, either the device will return, or devloss_tmo will fire,
2076  * and when the timeout then fires, it will be handled normally.
2077  * If the rport is not blocked, normal error handling continues.
2078  *
2079  * Notes:
2080  *	This routine assumes no locks are held on entry.
2081  */
2082 enum blk_eh_timer_return
2083 fc_eh_timed_out(struct scsi_cmnd *scmd)
2084 {
2085 	struct fc_rport *rport = starget_to_rport(scsi_target(scmd->device));
2086 
2087 	if (rport->port_state == FC_PORTSTATE_BLOCKED)
2088 		return BLK_EH_RESET_TIMER;
2089 
2090 	return BLK_EH_DONE;
2091 }
2092 EXPORT_SYMBOL(fc_eh_timed_out);
2093 
2094 /*
2095  * Called by fc_user_scan to locate an rport on the shost that
2096  * matches the channel and target id, and invoke scsi_scan_target()
2097  * on the rport.
2098  */
2099 static void
2100 fc_user_scan_tgt(struct Scsi_Host *shost, uint channel, uint id, u64 lun)
2101 {
2102 	struct fc_rport *rport;
2103 	unsigned long flags;
2104 
2105 	spin_lock_irqsave(shost->host_lock, flags);
2106 
2107 	list_for_each_entry(rport, &fc_host_rports(shost), peers) {
2108 		if (rport->scsi_target_id == -1)
2109 			continue;
2110 
2111 		if (rport->port_state != FC_PORTSTATE_ONLINE)
2112 			continue;
2113 
2114 		if ((channel == rport->channel) &&
2115 		    (id == rport->scsi_target_id)) {
2116 			spin_unlock_irqrestore(shost->host_lock, flags);
2117 			scsi_scan_target(&rport->dev, channel, id, lun,
2118 					 SCSI_SCAN_MANUAL);
2119 			return;
2120 		}
2121 	}
2122 
2123 	spin_unlock_irqrestore(shost->host_lock, flags);
2124 }
2125 
2126 /*
2127  * Called via sysfs scan routines. Necessary, as the FC transport
2128  * wants to place all target objects below the rport object. So this
2129  * routine must invoke the scsi_scan_target() routine with the rport
2130  * object as the parent.
2131  */
2132 static int
2133 fc_user_scan(struct Scsi_Host *shost, uint channel, uint id, u64 lun)
2134 {
2135 	uint chlo, chhi;
2136 	uint tgtlo, tgthi;
2137 
2138 	if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) ||
2139 	    ((id != SCAN_WILD_CARD) && (id >= shost->max_id)) ||
2140 	    ((lun != SCAN_WILD_CARD) && (lun > shost->max_lun)))
2141 		return -EINVAL;
2142 
2143 	if (channel == SCAN_WILD_CARD) {
2144 		chlo = 0;
2145 		chhi = shost->max_channel + 1;
2146 	} else {
2147 		chlo = channel;
2148 		chhi = channel + 1;
2149 	}
2150 
2151 	if (id == SCAN_WILD_CARD) {
2152 		tgtlo = 0;
2153 		tgthi = shost->max_id;
2154 	} else {
2155 		tgtlo = id;
2156 		tgthi = id + 1;
2157 	}
2158 
2159 	for ( ; chlo < chhi; chlo++)
2160 		for ( ; tgtlo < tgthi; tgtlo++)
2161 			fc_user_scan_tgt(shost, chlo, tgtlo, lun);
2162 
2163 	return 0;
2164 }
2165 
2166 struct scsi_transport_template *
2167 fc_attach_transport(struct fc_function_template *ft)
2168 {
2169 	int count;
2170 	struct fc_internal *i = kzalloc(sizeof(struct fc_internal),
2171 					GFP_KERNEL);
2172 
2173 	if (unlikely(!i))
2174 		return NULL;
2175 
2176 	i->t.target_attrs.ac.attrs = &i->starget_attrs[0];
2177 	i->t.target_attrs.ac.class = &fc_transport_class.class;
2178 	i->t.target_attrs.ac.match = fc_target_match;
2179 	i->t.target_size = sizeof(struct fc_starget_attrs);
2180 	transport_container_register(&i->t.target_attrs);
2181 
2182 	i->t.host_attrs.ac.attrs = &i->host_attrs[0];
2183 	i->t.host_attrs.ac.class = &fc_host_class.class;
2184 	i->t.host_attrs.ac.match = fc_host_match;
2185 	i->t.host_size = sizeof(struct fc_host_attrs);
2186 	if (ft->get_fc_host_stats)
2187 		i->t.host_attrs.statistics = &fc_statistics_group;
2188 	transport_container_register(&i->t.host_attrs);
2189 
2190 	i->rport_attr_cont.ac.attrs = &i->rport_attrs[0];
2191 	i->rport_attr_cont.ac.class = &fc_rport_class.class;
2192 	i->rport_attr_cont.ac.match = fc_rport_match;
2193 	transport_container_register(&i->rport_attr_cont);
2194 
2195 	i->vport_attr_cont.ac.attrs = &i->vport_attrs[0];
2196 	i->vport_attr_cont.ac.class = &fc_vport_class.class;
2197 	i->vport_attr_cont.ac.match = fc_vport_match;
2198 	transport_container_register(&i->vport_attr_cont);
2199 
2200 	i->f = ft;
2201 
2202 	/* Transport uses the shost workq for scsi scanning */
2203 	i->t.create_work_queue = 1;
2204 
2205 	i->t.user_scan = fc_user_scan;
2206 
2207 	/*
2208 	 * Setup SCSI Target Attributes.
2209 	 */
2210 	count = 0;
2211 	SETUP_STARGET_ATTRIBUTE_RD(node_name);
2212 	SETUP_STARGET_ATTRIBUTE_RD(port_name);
2213 	SETUP_STARGET_ATTRIBUTE_RD(port_id);
2214 
2215 	BUG_ON(count > FC_STARGET_NUM_ATTRS);
2216 
2217 	i->starget_attrs[count] = NULL;
2218 
2219 
2220 	/*
2221 	 * Setup SCSI Host Attributes.
2222 	 */
2223 	count=0;
2224 	SETUP_HOST_ATTRIBUTE_RD(node_name);
2225 	SETUP_HOST_ATTRIBUTE_RD(port_name);
2226 	SETUP_HOST_ATTRIBUTE_RD(permanent_port_name);
2227 	SETUP_HOST_ATTRIBUTE_RD(supported_classes);
2228 	SETUP_HOST_ATTRIBUTE_RD(supported_fc4s);
2229 	SETUP_HOST_ATTRIBUTE_RD(supported_speeds);
2230 	SETUP_HOST_ATTRIBUTE_RD(maxframe_size);
2231 	if (ft->vport_create) {
2232 		SETUP_HOST_ATTRIBUTE_RD_NS(max_npiv_vports);
2233 		SETUP_HOST_ATTRIBUTE_RD_NS(npiv_vports_inuse);
2234 	}
2235 	SETUP_HOST_ATTRIBUTE_RD(serial_number);
2236 	SETUP_HOST_ATTRIBUTE_RD(manufacturer);
2237 	SETUP_HOST_ATTRIBUTE_RD(model);
2238 	SETUP_HOST_ATTRIBUTE_RD(model_description);
2239 	SETUP_HOST_ATTRIBUTE_RD(hardware_version);
2240 	SETUP_HOST_ATTRIBUTE_RD(driver_version);
2241 	SETUP_HOST_ATTRIBUTE_RD(firmware_version);
2242 	SETUP_HOST_ATTRIBUTE_RD(optionrom_version);
2243 
2244 	SETUP_HOST_ATTRIBUTE_RD(port_id);
2245 	SETUP_HOST_ATTRIBUTE_RD(port_type);
2246 	SETUP_HOST_ATTRIBUTE_RD(port_state);
2247 	SETUP_HOST_ATTRIBUTE_RD(active_fc4s);
2248 	SETUP_HOST_ATTRIBUTE_RD(speed);
2249 	SETUP_HOST_ATTRIBUTE_RD(fabric_name);
2250 	SETUP_HOST_ATTRIBUTE_RD(symbolic_name);
2251 	SETUP_HOST_ATTRIBUTE_RW(system_hostname);
2252 
2253 	/* Transport-managed attributes */
2254 	SETUP_PRIVATE_HOST_ATTRIBUTE_RW(dev_loss_tmo);
2255 	SETUP_PRIVATE_HOST_ATTRIBUTE_RW(tgtid_bind_type);
2256 	if (ft->issue_fc_host_lip)
2257 		SETUP_PRIVATE_HOST_ATTRIBUTE_RW(issue_lip);
2258 	if (ft->vport_create)
2259 		SETUP_PRIVATE_HOST_ATTRIBUTE_RW(vport_create);
2260 	if (ft->vport_delete)
2261 		SETUP_PRIVATE_HOST_ATTRIBUTE_RW(vport_delete);
2262 
2263 	BUG_ON(count > FC_HOST_NUM_ATTRS);
2264 
2265 	i->host_attrs[count] = NULL;
2266 
2267 	/*
2268 	 * Setup Remote Port Attributes.
2269 	 */
2270 	count=0;
2271 	SETUP_RPORT_ATTRIBUTE_RD(maxframe_size);
2272 	SETUP_RPORT_ATTRIBUTE_RD(supported_classes);
2273 	SETUP_RPORT_ATTRIBUTE_RW(dev_loss_tmo);
2274 	SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(node_name);
2275 	SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(port_name);
2276 	SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(port_id);
2277 	SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(roles);
2278 	SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(port_state);
2279 	SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(scsi_target_id);
2280 	SETUP_PRIVATE_RPORT_ATTRIBUTE_RW(fast_io_fail_tmo);
2281 
2282 	BUG_ON(count > FC_RPORT_NUM_ATTRS);
2283 
2284 	i->rport_attrs[count] = NULL;
2285 
2286 	/*
2287 	 * Setup Virtual Port Attributes.
2288 	 */
2289 	count=0;
2290 	SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(vport_state);
2291 	SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(vport_last_state);
2292 	SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(node_name);
2293 	SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(port_name);
2294 	SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(roles);
2295 	SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(vport_type);
2296 	SETUP_VPORT_ATTRIBUTE_RW(symbolic_name);
2297 	SETUP_VPORT_ATTRIBUTE_WR(vport_delete);
2298 	SETUP_VPORT_ATTRIBUTE_WR(vport_disable);
2299 
2300 	BUG_ON(count > FC_VPORT_NUM_ATTRS);
2301 
2302 	i->vport_attrs[count] = NULL;
2303 
2304 	return &i->t;
2305 }
2306 EXPORT_SYMBOL(fc_attach_transport);
2307 
2308 void fc_release_transport(struct scsi_transport_template *t)
2309 {
2310 	struct fc_internal *i = to_fc_internal(t);
2311 
2312 	transport_container_unregister(&i->t.target_attrs);
2313 	transport_container_unregister(&i->t.host_attrs);
2314 	transport_container_unregister(&i->rport_attr_cont);
2315 	transport_container_unregister(&i->vport_attr_cont);
2316 
2317 	kfree(i);
2318 }
2319 EXPORT_SYMBOL(fc_release_transport);
2320 
2321 /**
2322  * fc_queue_work - Queue work to the fc_host workqueue.
2323  * @shost:	Pointer to Scsi_Host bound to fc_host.
2324  * @work:	Work to queue for execution.
2325  *
2326  * Return value:
2327  * 	1 - work queued for execution
2328  *	0 - work is already queued
2329  *	-EINVAL - work queue doesn't exist
2330  */
2331 static int
2332 fc_queue_work(struct Scsi_Host *shost, struct work_struct *work)
2333 {
2334 	if (unlikely(!fc_host_work_q(shost))) {
2335 		printk(KERN_ERR
2336 			"ERROR: FC host '%s' attempted to queue work, "
2337 			"when no workqueue created.\n", shost->hostt->name);
2338 		dump_stack();
2339 
2340 		return -EINVAL;
2341 	}
2342 
2343 	return queue_work(fc_host_work_q(shost), work);
2344 }
2345 
2346 /**
2347  * fc_flush_work - Flush a fc_host's workqueue.
2348  * @shost:	Pointer to Scsi_Host bound to fc_host.
2349  */
2350 static void
2351 fc_flush_work(struct Scsi_Host *shost)
2352 {
2353 	if (!fc_host_work_q(shost)) {
2354 		printk(KERN_ERR
2355 			"ERROR: FC host '%s' attempted to flush work, "
2356 			"when no workqueue created.\n", shost->hostt->name);
2357 		dump_stack();
2358 		return;
2359 	}
2360 
2361 	flush_workqueue(fc_host_work_q(shost));
2362 }
2363 
2364 /**
2365  * fc_queue_devloss_work - Schedule work for the fc_host devloss workqueue.
2366  * @shost:	Pointer to Scsi_Host bound to fc_host.
2367  * @work:	Work to queue for execution.
2368  * @delay:	jiffies to delay the work queuing
2369  *
2370  * Return value:
2371  * 	1 on success / 0 already queued / < 0 for error
2372  */
2373 static int
2374 fc_queue_devloss_work(struct Scsi_Host *shost, struct delayed_work *work,
2375 				unsigned long delay)
2376 {
2377 	if (unlikely(!fc_host_devloss_work_q(shost))) {
2378 		printk(KERN_ERR
2379 			"ERROR: FC host '%s' attempted to queue work, "
2380 			"when no workqueue created.\n", shost->hostt->name);
2381 		dump_stack();
2382 
2383 		return -EINVAL;
2384 	}
2385 
2386 	return queue_delayed_work(fc_host_devloss_work_q(shost), work, delay);
2387 }
2388 
2389 /**
2390  * fc_flush_devloss - Flush a fc_host's devloss workqueue.
2391  * @shost:	Pointer to Scsi_Host bound to fc_host.
2392  */
2393 static void
2394 fc_flush_devloss(struct Scsi_Host *shost)
2395 {
2396 	if (!fc_host_devloss_work_q(shost)) {
2397 		printk(KERN_ERR
2398 			"ERROR: FC host '%s' attempted to flush work, "
2399 			"when no workqueue created.\n", shost->hostt->name);
2400 		dump_stack();
2401 		return;
2402 	}
2403 
2404 	flush_workqueue(fc_host_devloss_work_q(shost));
2405 }
2406 
2407 
2408 /**
2409  * fc_remove_host - called to terminate any fc_transport-related elements for a scsi host.
2410  * @shost:	Which &Scsi_Host
2411  *
2412  * This routine is expected to be called immediately preceding the
2413  * a driver's call to scsi_remove_host().
2414  *
2415  * WARNING: A driver utilizing the fc_transport, which fails to call
2416  *   this routine prior to scsi_remove_host(), will leave dangling
2417  *   objects in /sys/class/fc_remote_ports. Access to any of these
2418  *   objects can result in a system crash !!!
2419  *
2420  * Notes:
2421  *	This routine assumes no locks are held on entry.
2422  */
2423 void
2424 fc_remove_host(struct Scsi_Host *shost)
2425 {
2426 	struct fc_vport *vport = NULL, *next_vport = NULL;
2427 	struct fc_rport *rport = NULL, *next_rport = NULL;
2428 	struct workqueue_struct *work_q;
2429 	struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
2430 	unsigned long flags;
2431 
2432 	spin_lock_irqsave(shost->host_lock, flags);
2433 
2434 	/* Remove any vports */
2435 	list_for_each_entry_safe(vport, next_vport, &fc_host->vports, peers) {
2436 		vport->flags |= FC_VPORT_DELETING;
2437 		fc_queue_work(shost, &vport->vport_delete_work);
2438 	}
2439 
2440 	/* Remove any remote ports */
2441 	list_for_each_entry_safe(rport, next_rport,
2442 			&fc_host->rports, peers) {
2443 		list_del(&rport->peers);
2444 		rport->port_state = FC_PORTSTATE_DELETED;
2445 		fc_queue_work(shost, &rport->rport_delete_work);
2446 	}
2447 
2448 	list_for_each_entry_safe(rport, next_rport,
2449 			&fc_host->rport_bindings, peers) {
2450 		list_del(&rport->peers);
2451 		rport->port_state = FC_PORTSTATE_DELETED;
2452 		fc_queue_work(shost, &rport->rport_delete_work);
2453 	}
2454 
2455 	spin_unlock_irqrestore(shost->host_lock, flags);
2456 
2457 	/* flush all scan work items */
2458 	scsi_flush_work(shost);
2459 
2460 	/* flush all stgt delete, and rport delete work items, then kill it  */
2461 	if (fc_host->work_q) {
2462 		work_q = fc_host->work_q;
2463 		fc_host->work_q = NULL;
2464 		destroy_workqueue(work_q);
2465 	}
2466 
2467 	/* flush all devloss work items, then kill it  */
2468 	if (fc_host->devloss_work_q) {
2469 		work_q = fc_host->devloss_work_q;
2470 		fc_host->devloss_work_q = NULL;
2471 		destroy_workqueue(work_q);
2472 	}
2473 }
2474 EXPORT_SYMBOL(fc_remove_host);
2475 
2476 static void fc_terminate_rport_io(struct fc_rport *rport)
2477 {
2478 	struct Scsi_Host *shost = rport_to_shost(rport);
2479 	struct fc_internal *i = to_fc_internal(shost->transportt);
2480 
2481 	/* Involve the LLDD if possible to terminate all io on the rport. */
2482 	if (i->f->terminate_rport_io)
2483 		i->f->terminate_rport_io(rport);
2484 
2485 	/*
2486 	 * Must unblock to flush queued IO. scsi-ml will fail incoming reqs.
2487 	 */
2488 	scsi_target_unblock(&rport->dev, SDEV_TRANSPORT_OFFLINE);
2489 }
2490 
2491 /**
2492  * fc_starget_delete - called to delete the scsi descendants of an rport
2493  * @work:	remote port to be operated on.
2494  *
2495  * Deletes target and all sdevs.
2496  */
2497 static void
2498 fc_starget_delete(struct work_struct *work)
2499 {
2500 	struct fc_rport *rport =
2501 		container_of(work, struct fc_rport, stgt_delete_work);
2502 
2503 	fc_terminate_rport_io(rport);
2504 	scsi_remove_target(&rport->dev);
2505 }
2506 
2507 
2508 /**
2509  * fc_rport_final_delete - finish rport termination and delete it.
2510  * @work:	remote port to be deleted.
2511  */
2512 static void
2513 fc_rport_final_delete(struct work_struct *work)
2514 {
2515 	struct fc_rport *rport =
2516 		container_of(work, struct fc_rport, rport_delete_work);
2517 	struct device *dev = &rport->dev;
2518 	struct Scsi_Host *shost = rport_to_shost(rport);
2519 	struct fc_internal *i = to_fc_internal(shost->transportt);
2520 	unsigned long flags;
2521 	int do_callback = 0;
2522 
2523 	fc_terminate_rport_io(rport);
2524 
2525 	/*
2526 	 * if a scan is pending, flush the SCSI Host work_q so that
2527 	 * that we can reclaim the rport scan work element.
2528 	 */
2529 	if (rport->flags & FC_RPORT_SCAN_PENDING)
2530 		scsi_flush_work(shost);
2531 
2532 	/*
2533 	 * Cancel any outstanding timers. These should really exist
2534 	 * only when rmmod'ing the LLDD and we're asking for
2535 	 * immediate termination of the rports
2536 	 */
2537 	spin_lock_irqsave(shost->host_lock, flags);
2538 	if (rport->flags & FC_RPORT_DEVLOSS_PENDING) {
2539 		spin_unlock_irqrestore(shost->host_lock, flags);
2540 		if (!cancel_delayed_work(&rport->fail_io_work))
2541 			fc_flush_devloss(shost);
2542 		if (!cancel_delayed_work(&rport->dev_loss_work))
2543 			fc_flush_devloss(shost);
2544 		cancel_work_sync(&rport->scan_work);
2545 		spin_lock_irqsave(shost->host_lock, flags);
2546 		rport->flags &= ~FC_RPORT_DEVLOSS_PENDING;
2547 	}
2548 	spin_unlock_irqrestore(shost->host_lock, flags);
2549 
2550 	/* Delete SCSI target and sdevs */
2551 	if (rport->scsi_target_id != -1)
2552 		fc_starget_delete(&rport->stgt_delete_work);
2553 
2554 	/*
2555 	 * Notify the driver that the rport is now dead. The LLDD will
2556 	 * also guarantee that any communication to the rport is terminated
2557 	 *
2558 	 * Avoid this call if we already called it when we preserved the
2559 	 * rport for the binding.
2560 	 */
2561 	spin_lock_irqsave(shost->host_lock, flags);
2562 	if (!(rport->flags & FC_RPORT_DEVLOSS_CALLBK_DONE) &&
2563 	    (i->f->dev_loss_tmo_callbk)) {
2564 		rport->flags |= FC_RPORT_DEVLOSS_CALLBK_DONE;
2565 		do_callback = 1;
2566 	}
2567 	spin_unlock_irqrestore(shost->host_lock, flags);
2568 
2569 	if (do_callback)
2570 		i->f->dev_loss_tmo_callbk(rport);
2571 
2572 	fc_bsg_remove(rport->rqst_q);
2573 
2574 	transport_remove_device(dev);
2575 	device_del(dev);
2576 	transport_destroy_device(dev);
2577 	scsi_host_put(shost);			/* for fc_host->rport list */
2578 	put_device(dev);			/* for self-reference */
2579 }
2580 
2581 
2582 /**
2583  * fc_remote_port_create - allocates and creates a remote FC port.
2584  * @shost:	scsi host the remote port is connected to.
2585  * @channel:	Channel on shost port connected to.
2586  * @ids:	The world wide names, fc address, and FC4 port
2587  *		roles for the remote port.
2588  *
2589  * Allocates and creates the remoter port structure, including the
2590  * class and sysfs creation.
2591  *
2592  * Notes:
2593  *	This routine assumes no locks are held on entry.
2594  */
2595 static struct fc_rport *
2596 fc_remote_port_create(struct Scsi_Host *shost, int channel,
2597 		      struct fc_rport_identifiers  *ids)
2598 {
2599 	struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
2600 	struct fc_internal *fci = to_fc_internal(shost->transportt);
2601 	struct fc_rport *rport;
2602 	struct device *dev;
2603 	unsigned long flags;
2604 	int error;
2605 	size_t size;
2606 
2607 	size = (sizeof(struct fc_rport) + fci->f->dd_fcrport_size);
2608 	rport = kzalloc(size, GFP_KERNEL);
2609 	if (unlikely(!rport)) {
2610 		printk(KERN_ERR "%s: allocation failure\n", __func__);
2611 		return NULL;
2612 	}
2613 
2614 	rport->maxframe_size = -1;
2615 	rport->supported_classes = FC_COS_UNSPECIFIED;
2616 	rport->dev_loss_tmo = fc_host->dev_loss_tmo;
2617 	memcpy(&rport->node_name, &ids->node_name, sizeof(rport->node_name));
2618 	memcpy(&rport->port_name, &ids->port_name, sizeof(rport->port_name));
2619 	rport->port_id = ids->port_id;
2620 	rport->roles = ids->roles;
2621 	rport->port_state = FC_PORTSTATE_ONLINE;
2622 	if (fci->f->dd_fcrport_size)
2623 		rport->dd_data = &rport[1];
2624 	rport->channel = channel;
2625 	rport->fast_io_fail_tmo = -1;
2626 
2627 	INIT_DELAYED_WORK(&rport->dev_loss_work, fc_timeout_deleted_rport);
2628 	INIT_DELAYED_WORK(&rport->fail_io_work, fc_timeout_fail_rport_io);
2629 	INIT_WORK(&rport->scan_work, fc_scsi_scan_rport);
2630 	INIT_WORK(&rport->stgt_delete_work, fc_starget_delete);
2631 	INIT_WORK(&rport->rport_delete_work, fc_rport_final_delete);
2632 
2633 	spin_lock_irqsave(shost->host_lock, flags);
2634 
2635 	rport->number = fc_host->next_rport_number++;
2636 	if ((rport->roles & FC_PORT_ROLE_FCP_TARGET) ||
2637 	    (rport->roles & FC_PORT_ROLE_FCP_DUMMY_INITIATOR))
2638 		rport->scsi_target_id = fc_host->next_target_id++;
2639 	else
2640 		rport->scsi_target_id = -1;
2641 	list_add_tail(&rport->peers, &fc_host->rports);
2642 	scsi_host_get(shost);			/* for fc_host->rport list */
2643 
2644 	spin_unlock_irqrestore(shost->host_lock, flags);
2645 
2646 	dev = &rport->dev;
2647 	device_initialize(dev);			/* takes self reference */
2648 	dev->parent = get_device(&shost->shost_gendev); /* parent reference */
2649 	dev->release = fc_rport_dev_release;
2650 	dev_set_name(dev, "rport-%d:%d-%d",
2651 		     shost->host_no, channel, rport->number);
2652 	transport_setup_device(dev);
2653 
2654 	error = device_add(dev);
2655 	if (error) {
2656 		printk(KERN_ERR "FC Remote Port device_add failed\n");
2657 		goto delete_rport;
2658 	}
2659 	transport_add_device(dev);
2660 	transport_configure_device(dev);
2661 
2662 	fc_bsg_rportadd(shost, rport);
2663 	/* ignore any bsg add error - we just can't do sgio */
2664 
2665 	if (rport->roles & FC_PORT_ROLE_FCP_TARGET) {
2666 		/* initiate a scan of the target */
2667 		rport->flags |= FC_RPORT_SCAN_PENDING;
2668 		scsi_queue_work(shost, &rport->scan_work);
2669 	}
2670 
2671 	return rport;
2672 
2673 delete_rport:
2674 	transport_destroy_device(dev);
2675 	spin_lock_irqsave(shost->host_lock, flags);
2676 	list_del(&rport->peers);
2677 	scsi_host_put(shost);			/* for fc_host->rport list */
2678 	spin_unlock_irqrestore(shost->host_lock, flags);
2679 	put_device(dev->parent);
2680 	kfree(rport);
2681 	return NULL;
2682 }
2683 
2684 /**
2685  * fc_remote_port_add - notify fc transport of the existence of a remote FC port.
2686  * @shost:	scsi host the remote port is connected to.
2687  * @channel:	Channel on shost port connected to.
2688  * @ids:	The world wide names, fc address, and FC4 port
2689  *		roles for the remote port.
2690  *
2691  * The LLDD calls this routine to notify the transport of the existence
2692  * of a remote port. The LLDD provides the unique identifiers (wwpn,wwn)
2693  * of the port, it's FC address (port_id), and the FC4 roles that are
2694  * active for the port.
2695  *
2696  * For ports that are FCP targets (aka scsi targets), the FC transport
2697  * maintains consistent target id bindings on behalf of the LLDD.
2698  * A consistent target id binding is an assignment of a target id to
2699  * a remote port identifier, which persists while the scsi host is
2700  * attached. The remote port can disappear, then later reappear, and
2701  * it's target id assignment remains the same. This allows for shifts
2702  * in FC addressing (if binding by wwpn or wwnn) with no apparent
2703  * changes to the scsi subsystem which is based on scsi host number and
2704  * target id values.  Bindings are only valid during the attachment of
2705  * the scsi host. If the host detaches, then later re-attaches, target
2706  * id bindings may change.
2707  *
2708  * This routine is responsible for returning a remote port structure.
2709  * The routine will search the list of remote ports it maintains
2710  * internally on behalf of consistent target id mappings. If found, the
2711  * remote port structure will be reused. Otherwise, a new remote port
2712  * structure will be allocated.
2713  *
2714  * Whenever a remote port is allocated, a new fc_remote_port class
2715  * device is created.
2716  *
2717  * Should not be called from interrupt context.
2718  *
2719  * Notes:
2720  *	This routine assumes no locks are held on entry.
2721  */
2722 struct fc_rport *
2723 fc_remote_port_add(struct Scsi_Host *shost, int channel,
2724 	struct fc_rport_identifiers  *ids)
2725 {
2726 	struct fc_internal *fci = to_fc_internal(shost->transportt);
2727 	struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
2728 	struct fc_rport *rport;
2729 	unsigned long flags;
2730 	int match = 0;
2731 
2732 	/* ensure any stgt delete functions are done */
2733 	fc_flush_work(shost);
2734 
2735 	/*
2736 	 * Search the list of "active" rports, for an rport that has been
2737 	 * deleted, but we've held off the real delete while the target
2738 	 * is in a "blocked" state.
2739 	 */
2740 	spin_lock_irqsave(shost->host_lock, flags);
2741 
2742 	list_for_each_entry(rport, &fc_host->rports, peers) {
2743 
2744 		if ((rport->port_state == FC_PORTSTATE_BLOCKED ||
2745 		     rport->port_state == FC_PORTSTATE_NOTPRESENT) &&
2746 			(rport->channel == channel)) {
2747 
2748 			switch (fc_host->tgtid_bind_type) {
2749 			case FC_TGTID_BIND_BY_WWPN:
2750 			case FC_TGTID_BIND_NONE:
2751 				if (rport->port_name == ids->port_name)
2752 					match = 1;
2753 				break;
2754 			case FC_TGTID_BIND_BY_WWNN:
2755 				if (rport->node_name == ids->node_name)
2756 					match = 1;
2757 				break;
2758 			case FC_TGTID_BIND_BY_ID:
2759 				if (rport->port_id == ids->port_id)
2760 					match = 1;
2761 				break;
2762 			}
2763 
2764 			if (match) {
2765 
2766 				memcpy(&rport->node_name, &ids->node_name,
2767 					sizeof(rport->node_name));
2768 				memcpy(&rport->port_name, &ids->port_name,
2769 					sizeof(rport->port_name));
2770 				rport->port_id = ids->port_id;
2771 
2772 				rport->port_state = FC_PORTSTATE_ONLINE;
2773 				rport->roles = ids->roles;
2774 
2775 				spin_unlock_irqrestore(shost->host_lock, flags);
2776 
2777 				if (fci->f->dd_fcrport_size)
2778 					memset(rport->dd_data, 0,
2779 						fci->f->dd_fcrport_size);
2780 
2781 				/*
2782 				 * If we were not a target, cancel the
2783 				 * io terminate and rport timers, and
2784 				 * we're done.
2785 				 *
2786 				 * If we were a target, but our new role
2787 				 * doesn't indicate a target, leave the
2788 				 * timers running expecting the role to
2789 				 * change as the target fully logs in. If
2790 				 * it doesn't, the target will be torn down.
2791 				 *
2792 				 * If we were a target, and our role shows
2793 				 * we're still a target, cancel the timers
2794 				 * and kick off a scan.
2795 				 */
2796 
2797 				/* was a target, not in roles */
2798 				if ((rport->scsi_target_id != -1) &&
2799 				    (!(ids->roles & FC_PORT_ROLE_FCP_TARGET)))
2800 					return rport;
2801 
2802 				/*
2803 				 * Stop the fail io and dev_loss timers.
2804 				 * If they flush, the port_state will
2805 				 * be checked and will NOOP the function.
2806 				 */
2807 				if (!cancel_delayed_work(&rport->fail_io_work))
2808 					fc_flush_devloss(shost);
2809 				if (!cancel_delayed_work(&rport->dev_loss_work))
2810 					fc_flush_devloss(shost);
2811 
2812 				spin_lock_irqsave(shost->host_lock, flags);
2813 
2814 				rport->flags &= ~(FC_RPORT_FAST_FAIL_TIMEDOUT |
2815 						  FC_RPORT_DEVLOSS_PENDING |
2816 						  FC_RPORT_DEVLOSS_CALLBK_DONE);
2817 
2818 				spin_unlock_irqrestore(shost->host_lock, flags);
2819 
2820 				/* if target, initiate a scan */
2821 				if (rport->scsi_target_id != -1) {
2822 					scsi_target_unblock(&rport->dev,
2823 							    SDEV_RUNNING);
2824 					spin_lock_irqsave(shost->host_lock,
2825 							  flags);
2826 					rport->flags |= FC_RPORT_SCAN_PENDING;
2827 					scsi_queue_work(shost,
2828 							&rport->scan_work);
2829 					spin_unlock_irqrestore(shost->host_lock,
2830 							flags);
2831 				}
2832 
2833 				fc_bsg_goose_queue(rport);
2834 
2835 				return rport;
2836 			}
2837 		}
2838 	}
2839 
2840 	/*
2841 	 * Search the bindings array
2842 	 * Note: if never a FCP target, you won't be on this list
2843 	 */
2844 	if (fc_host->tgtid_bind_type != FC_TGTID_BIND_NONE) {
2845 
2846 		/* search for a matching consistent binding */
2847 
2848 		list_for_each_entry(rport, &fc_host->rport_bindings,
2849 					peers) {
2850 			if (rport->channel != channel)
2851 				continue;
2852 
2853 			switch (fc_host->tgtid_bind_type) {
2854 			case FC_TGTID_BIND_BY_WWPN:
2855 				if (rport->port_name == ids->port_name)
2856 					match = 1;
2857 				break;
2858 			case FC_TGTID_BIND_BY_WWNN:
2859 				if (rport->node_name == ids->node_name)
2860 					match = 1;
2861 				break;
2862 			case FC_TGTID_BIND_BY_ID:
2863 				if (rport->port_id == ids->port_id)
2864 					match = 1;
2865 				break;
2866 			case FC_TGTID_BIND_NONE: /* to keep compiler happy */
2867 				break;
2868 			}
2869 
2870 			if (match) {
2871 				list_move_tail(&rport->peers, &fc_host->rports);
2872 				break;
2873 			}
2874 		}
2875 
2876 		if (match) {
2877 			memcpy(&rport->node_name, &ids->node_name,
2878 				sizeof(rport->node_name));
2879 			memcpy(&rport->port_name, &ids->port_name,
2880 				sizeof(rport->port_name));
2881 			rport->port_id = ids->port_id;
2882 			rport->port_state = FC_PORTSTATE_ONLINE;
2883 			rport->flags &= ~FC_RPORT_FAST_FAIL_TIMEDOUT;
2884 
2885 			if (fci->f->dd_fcrport_size)
2886 				memset(rport->dd_data, 0,
2887 						fci->f->dd_fcrport_size);
2888 			spin_unlock_irqrestore(shost->host_lock, flags);
2889 
2890 			fc_remote_port_rolechg(rport, ids->roles);
2891 			return rport;
2892 		}
2893 	}
2894 
2895 	spin_unlock_irqrestore(shost->host_lock, flags);
2896 
2897 	/* No consistent binding found - create new remote port entry */
2898 	rport = fc_remote_port_create(shost, channel, ids);
2899 
2900 	return rport;
2901 }
2902 EXPORT_SYMBOL(fc_remote_port_add);
2903 
2904 
2905 /**
2906  * fc_remote_port_delete - notifies the fc transport that a remote port is no longer in existence.
2907  * @rport:	The remote port that no longer exists
2908  *
2909  * The LLDD calls this routine to notify the transport that a remote
2910  * port is no longer part of the topology. Note: Although a port
2911  * may no longer be part of the topology, it may persist in the remote
2912  * ports displayed by the fc_host. We do this under 2 conditions:
2913  *
2914  * 1) If the port was a scsi target, we delay its deletion by "blocking" it.
2915  *    This allows the port to temporarily disappear, then reappear without
2916  *    disrupting the SCSI device tree attached to it. During the "blocked"
2917  *    period the port will still exist.
2918  *
2919  * 2) If the port was a scsi target and disappears for longer than we
2920  *    expect, we'll delete the port and the tear down the SCSI device tree
2921  *    attached to it. However, we want to semi-persist the target id assigned
2922  *    to that port if it eventually does exist. The port structure will
2923  *    remain (although with minimal information) so that the target id
2924  *    bindings also remain.
2925  *
2926  * If the remote port is not an FCP Target, it will be fully torn down
2927  * and deallocated, including the fc_remote_port class device.
2928  *
2929  * If the remote port is an FCP Target, the port will be placed in a
2930  * temporary blocked state. From the LLDD's perspective, the rport no
2931  * longer exists. From the SCSI midlayer's perspective, the SCSI target
2932  * exists, but all sdevs on it are blocked from further I/O. The following
2933  * is then expected.
2934  *
2935  *   If the remote port does not return (signaled by a LLDD call to
2936  *   fc_remote_port_add()) within the dev_loss_tmo timeout, then the
2937  *   scsi target is removed - killing all outstanding i/o and removing the
2938  *   scsi devices attached to it. The port structure will be marked Not
2939  *   Present and be partially cleared, leaving only enough information to
2940  *   recognize the remote port relative to the scsi target id binding if
2941  *   it later appears.  The port will remain as long as there is a valid
2942  *   binding (e.g. until the user changes the binding type or unloads the
2943  *   scsi host with the binding).
2944  *
2945  *   If the remote port returns within the dev_loss_tmo value (and matches
2946  *   according to the target id binding type), the port structure will be
2947  *   reused. If it is no longer a SCSI target, the target will be torn
2948  *   down. If it continues to be a SCSI target, then the target will be
2949  *   unblocked (allowing i/o to be resumed), and a scan will be activated
2950  *   to ensure that all luns are detected.
2951  *
2952  * Called from normal process context only - cannot be called from interrupt.
2953  *
2954  * Notes:
2955  *	This routine assumes no locks are held on entry.
2956  */
2957 void
2958 fc_remote_port_delete(struct fc_rport  *rport)
2959 {
2960 	struct Scsi_Host *shost = rport_to_shost(rport);
2961 	unsigned long timeout = rport->dev_loss_tmo;
2962 	unsigned long flags;
2963 
2964 	/*
2965 	 * No need to flush the fc_host work_q's, as all adds are synchronous.
2966 	 *
2967 	 * We do need to reclaim the rport scan work element, so eventually
2968 	 * (in fc_rport_final_delete()) we'll flush the scsi host work_q if
2969 	 * there's still a scan pending.
2970 	 */
2971 
2972 	spin_lock_irqsave(shost->host_lock, flags);
2973 
2974 	if (rport->port_state != FC_PORTSTATE_ONLINE) {
2975 		spin_unlock_irqrestore(shost->host_lock, flags);
2976 		return;
2977 	}
2978 
2979 	/*
2980 	 * In the past, we if this was not an FCP-Target, we would
2981 	 * unconditionally just jump to deleting the rport.
2982 	 * However, rports can be used as node containers by the LLDD,
2983 	 * and its not appropriate to just terminate the rport at the
2984 	 * first sign of a loss in connectivity. The LLDD may want to
2985 	 * send ELS traffic to re-validate the login. If the rport is
2986 	 * immediately deleted, it makes it inappropriate for a node
2987 	 * container.
2988 	 * So... we now unconditionally wait dev_loss_tmo before
2989 	 * destroying an rport.
2990 	 */
2991 
2992 	rport->port_state = FC_PORTSTATE_BLOCKED;
2993 
2994 	rport->flags |= FC_RPORT_DEVLOSS_PENDING;
2995 
2996 	spin_unlock_irqrestore(shost->host_lock, flags);
2997 
2998 	scsi_target_block(&rport->dev);
2999 
3000 	/* see if we need to kill io faster than waiting for device loss */
3001 	if ((rport->fast_io_fail_tmo != -1) &&
3002 	    (rport->fast_io_fail_tmo < timeout))
3003 		fc_queue_devloss_work(shost, &rport->fail_io_work,
3004 					rport->fast_io_fail_tmo * HZ);
3005 
3006 	/* cap the length the devices can be blocked until they are deleted */
3007 	fc_queue_devloss_work(shost, &rport->dev_loss_work, timeout * HZ);
3008 }
3009 EXPORT_SYMBOL(fc_remote_port_delete);
3010 
3011 /**
3012  * fc_remote_port_rolechg - notifies the fc transport that the roles on a remote may have changed.
3013  * @rport:	The remote port that changed.
3014  * @roles:      New roles for this port.
3015  *
3016  * Description: The LLDD calls this routine to notify the transport that the
3017  * roles on a remote port may have changed. The largest effect of this is
3018  * if a port now becomes a FCP Target, it must be allocated a
3019  * scsi target id.  If the port is no longer a FCP target, any
3020  * scsi target id value assigned to it will persist in case the
3021  * role changes back to include FCP Target. No changes in the scsi
3022  * midlayer will be invoked if the role changes (in the expectation
3023  * that the role will be resumed. If it doesn't normal error processing
3024  * will take place).
3025  *
3026  * Should not be called from interrupt context.
3027  *
3028  * Notes:
3029  *	This routine assumes no locks are held on entry.
3030  */
3031 void
3032 fc_remote_port_rolechg(struct fc_rport  *rport, u32 roles)
3033 {
3034 	struct Scsi_Host *shost = rport_to_shost(rport);
3035 	struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
3036 	unsigned long flags;
3037 	int create = 0;
3038 
3039 	spin_lock_irqsave(shost->host_lock, flags);
3040 	if (roles & FC_PORT_ROLE_FCP_TARGET) {
3041 		if (rport->scsi_target_id == -1) {
3042 			rport->scsi_target_id = fc_host->next_target_id++;
3043 			create = 1;
3044 		} else if (!(rport->roles & FC_PORT_ROLE_FCP_TARGET))
3045 			create = 1;
3046 	}
3047 
3048 	rport->roles = roles;
3049 
3050 	spin_unlock_irqrestore(shost->host_lock, flags);
3051 
3052 	if (create) {
3053 		/*
3054 		 * There may have been a delete timer running on the
3055 		 * port. Ensure that it is cancelled as we now know
3056 		 * the port is an FCP Target.
3057 		 * Note: we know the rport exists and is in an online
3058 		 *  state as the LLDD would not have had an rport
3059 		 *  reference to pass us.
3060 		 *
3061 		 * Take no action on the del_timer failure as the state
3062 		 * machine state change will validate the
3063 		 * transaction.
3064 		 */
3065 		if (!cancel_delayed_work(&rport->fail_io_work))
3066 			fc_flush_devloss(shost);
3067 		if (!cancel_delayed_work(&rport->dev_loss_work))
3068 			fc_flush_devloss(shost);
3069 
3070 		spin_lock_irqsave(shost->host_lock, flags);
3071 		rport->flags &= ~(FC_RPORT_FAST_FAIL_TIMEDOUT |
3072 				  FC_RPORT_DEVLOSS_PENDING |
3073 				  FC_RPORT_DEVLOSS_CALLBK_DONE);
3074 		spin_unlock_irqrestore(shost->host_lock, flags);
3075 
3076 		/* ensure any stgt delete functions are done */
3077 		fc_flush_work(shost);
3078 
3079 		scsi_target_unblock(&rport->dev, SDEV_RUNNING);
3080 		/* initiate a scan of the target */
3081 		spin_lock_irqsave(shost->host_lock, flags);
3082 		rport->flags |= FC_RPORT_SCAN_PENDING;
3083 		scsi_queue_work(shost, &rport->scan_work);
3084 		spin_unlock_irqrestore(shost->host_lock, flags);
3085 	}
3086 }
3087 EXPORT_SYMBOL(fc_remote_port_rolechg);
3088 
3089 /**
3090  * fc_timeout_deleted_rport - Timeout handler for a deleted remote port.
3091  * @work:	rport target that failed to reappear in the allotted time.
3092  *
3093  * Description: An attempt to delete a remote port blocks, and if it fails
3094  *              to return in the allotted time this gets called.
3095  */
3096 static void
3097 fc_timeout_deleted_rport(struct work_struct *work)
3098 {
3099 	struct fc_rport *rport =
3100 		container_of(work, struct fc_rport, dev_loss_work.work);
3101 	struct Scsi_Host *shost = rport_to_shost(rport);
3102 	struct fc_internal *i = to_fc_internal(shost->transportt);
3103 	struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
3104 	unsigned long flags;
3105 	int do_callback = 0;
3106 
3107 	spin_lock_irqsave(shost->host_lock, flags);
3108 
3109 	rport->flags &= ~FC_RPORT_DEVLOSS_PENDING;
3110 
3111 	/*
3112 	 * If the port is ONLINE, then it came back. If it was a SCSI
3113 	 * target, validate it still is. If not, tear down the
3114 	 * scsi_target on it.
3115 	 */
3116 	if ((rport->port_state == FC_PORTSTATE_ONLINE) &&
3117 	    (rport->scsi_target_id != -1) &&
3118 	    !(rport->roles & FC_PORT_ROLE_FCP_TARGET)) {
3119 		dev_printk(KERN_ERR, &rport->dev,
3120 			"blocked FC remote port time out: no longer"
3121 			" a FCP target, removing starget\n");
3122 		spin_unlock_irqrestore(shost->host_lock, flags);
3123 		scsi_target_unblock(&rport->dev, SDEV_TRANSPORT_OFFLINE);
3124 		fc_queue_work(shost, &rport->stgt_delete_work);
3125 		return;
3126 	}
3127 
3128 	/* NOOP state - we're flushing workq's */
3129 	if (rport->port_state != FC_PORTSTATE_BLOCKED) {
3130 		spin_unlock_irqrestore(shost->host_lock, flags);
3131 		dev_printk(KERN_ERR, &rport->dev,
3132 			"blocked FC remote port time out: leaving"
3133 			" rport%s alone\n",
3134 			(rport->scsi_target_id != -1) ?  " and starget" : "");
3135 		return;
3136 	}
3137 
3138 	if ((fc_host->tgtid_bind_type == FC_TGTID_BIND_NONE) ||
3139 	    (rport->scsi_target_id == -1)) {
3140 		list_del(&rport->peers);
3141 		rport->port_state = FC_PORTSTATE_DELETED;
3142 		dev_printk(KERN_ERR, &rport->dev,
3143 			"blocked FC remote port time out: removing"
3144 			" rport%s\n",
3145 			(rport->scsi_target_id != -1) ?  " and starget" : "");
3146 		fc_queue_work(shost, &rport->rport_delete_work);
3147 		spin_unlock_irqrestore(shost->host_lock, flags);
3148 		return;
3149 	}
3150 
3151 	dev_printk(KERN_ERR, &rport->dev,
3152 		"blocked FC remote port time out: removing target and "
3153 		"saving binding\n");
3154 
3155 	list_move_tail(&rport->peers, &fc_host->rport_bindings);
3156 
3157 	/*
3158 	 * Note: We do not remove or clear the hostdata area. This allows
3159 	 *   host-specific target data to persist along with the
3160 	 *   scsi_target_id. It's up to the host to manage it's hostdata area.
3161 	 */
3162 
3163 	/*
3164 	 * Reinitialize port attributes that may change if the port comes back.
3165 	 */
3166 	rport->maxframe_size = -1;
3167 	rport->supported_classes = FC_COS_UNSPECIFIED;
3168 	rport->roles = FC_PORT_ROLE_UNKNOWN;
3169 	rport->port_state = FC_PORTSTATE_NOTPRESENT;
3170 	rport->flags &= ~FC_RPORT_FAST_FAIL_TIMEDOUT;
3171 
3172 	/*
3173 	 * Pre-emptively kill I/O rather than waiting for the work queue
3174 	 * item to teardown the starget. (FCOE libFC folks prefer this
3175 	 * and to have the rport_port_id still set when it's done).
3176 	 */
3177 	spin_unlock_irqrestore(shost->host_lock, flags);
3178 	fc_terminate_rport_io(rport);
3179 
3180 	spin_lock_irqsave(shost->host_lock, flags);
3181 
3182 	if (rport->port_state == FC_PORTSTATE_NOTPRESENT) {	/* still missing */
3183 
3184 		/* remove the identifiers that aren't used in the consisting binding */
3185 		switch (fc_host->tgtid_bind_type) {
3186 		case FC_TGTID_BIND_BY_WWPN:
3187 			rport->node_name = -1;
3188 			rport->port_id = -1;
3189 			break;
3190 		case FC_TGTID_BIND_BY_WWNN:
3191 			rport->port_name = -1;
3192 			rport->port_id = -1;
3193 			break;
3194 		case FC_TGTID_BIND_BY_ID:
3195 			rport->node_name = -1;
3196 			rport->port_name = -1;
3197 			break;
3198 		case FC_TGTID_BIND_NONE:	/* to keep compiler happy */
3199 			break;
3200 		}
3201 
3202 		/*
3203 		 * As this only occurs if the remote port (scsi target)
3204 		 * went away and didn't come back - we'll remove
3205 		 * all attached scsi devices.
3206 		 */
3207 		rport->flags |= FC_RPORT_DEVLOSS_CALLBK_DONE;
3208 		fc_queue_work(shost, &rport->stgt_delete_work);
3209 
3210 		do_callback = 1;
3211 	}
3212 
3213 	spin_unlock_irqrestore(shost->host_lock, flags);
3214 
3215 	/*
3216 	 * Notify the driver that the rport is now dead. The LLDD will
3217 	 * also guarantee that any communication to the rport is terminated
3218 	 *
3219 	 * Note: we set the CALLBK_DONE flag above to correspond
3220 	 */
3221 	if (do_callback && i->f->dev_loss_tmo_callbk)
3222 		i->f->dev_loss_tmo_callbk(rport);
3223 }
3224 
3225 
3226 /**
3227  * fc_timeout_fail_rport_io - Timeout handler for a fast io failing on a disconnected SCSI target.
3228  * @work:	rport to terminate io on.
3229  *
3230  * Notes: Only requests the failure of the io, not that all are flushed
3231  *    prior to returning.
3232  */
3233 static void
3234 fc_timeout_fail_rport_io(struct work_struct *work)
3235 {
3236 	struct fc_rport *rport =
3237 		container_of(work, struct fc_rport, fail_io_work.work);
3238 
3239 	if (rport->port_state != FC_PORTSTATE_BLOCKED)
3240 		return;
3241 
3242 	rport->flags |= FC_RPORT_FAST_FAIL_TIMEDOUT;
3243 	fc_terminate_rport_io(rport);
3244 }
3245 
3246 /**
3247  * fc_scsi_scan_rport - called to perform a scsi scan on a remote port.
3248  * @work:	remote port to be scanned.
3249  */
3250 static void
3251 fc_scsi_scan_rport(struct work_struct *work)
3252 {
3253 	struct fc_rport *rport =
3254 		container_of(work, struct fc_rport, scan_work);
3255 	struct Scsi_Host *shost = rport_to_shost(rport);
3256 	struct fc_internal *i = to_fc_internal(shost->transportt);
3257 	unsigned long flags;
3258 
3259 	if ((rport->port_state == FC_PORTSTATE_ONLINE) &&
3260 	    (rport->roles & FC_PORT_ROLE_FCP_TARGET) &&
3261 	    !(i->f->disable_target_scan)) {
3262 		scsi_scan_target(&rport->dev, rport->channel,
3263 				 rport->scsi_target_id, SCAN_WILD_CARD,
3264 				 SCSI_SCAN_RESCAN);
3265 	}
3266 
3267 	spin_lock_irqsave(shost->host_lock, flags);
3268 	rport->flags &= ~FC_RPORT_SCAN_PENDING;
3269 	spin_unlock_irqrestore(shost->host_lock, flags);
3270 }
3271 
3272 /**
3273  * fc_block_rport() - Block SCSI eh thread for blocked fc_rport.
3274  * @rport: Remote port that scsi_eh is trying to recover.
3275  *
3276  * This routine can be called from a FC LLD scsi_eh callback. It
3277  * blocks the scsi_eh thread until the fc_rport leaves the
3278  * FC_PORTSTATE_BLOCKED, or the fast_io_fail_tmo fires. This is
3279  * necessary to avoid the scsi_eh failing recovery actions for blocked
3280  * rports which would lead to offlined SCSI devices.
3281  *
3282  * Returns: 0 if the fc_rport left the state FC_PORTSTATE_BLOCKED.
3283  *	    FAST_IO_FAIL if the fast_io_fail_tmo fired, this should be
3284  *	    passed back to scsi_eh.
3285  */
3286 int fc_block_rport(struct fc_rport *rport)
3287 {
3288 	struct Scsi_Host *shost = rport_to_shost(rport);
3289 	unsigned long flags;
3290 
3291 	spin_lock_irqsave(shost->host_lock, flags);
3292 	while (rport->port_state == FC_PORTSTATE_BLOCKED &&
3293 	       !(rport->flags & FC_RPORT_FAST_FAIL_TIMEDOUT)) {
3294 		spin_unlock_irqrestore(shost->host_lock, flags);
3295 		msleep(1000);
3296 		spin_lock_irqsave(shost->host_lock, flags);
3297 	}
3298 	spin_unlock_irqrestore(shost->host_lock, flags);
3299 
3300 	if (rport->flags & FC_RPORT_FAST_FAIL_TIMEDOUT)
3301 		return FAST_IO_FAIL;
3302 
3303 	return 0;
3304 }
3305 EXPORT_SYMBOL(fc_block_rport);
3306 
3307 /**
3308  * fc_block_scsi_eh - Block SCSI eh thread for blocked fc_rport
3309  * @cmnd: SCSI command that scsi_eh is trying to recover
3310  *
3311  * This routine can be called from a FC LLD scsi_eh callback. It
3312  * blocks the scsi_eh thread until the fc_rport leaves the
3313  * FC_PORTSTATE_BLOCKED, or the fast_io_fail_tmo fires. This is
3314  * necessary to avoid the scsi_eh failing recovery actions for blocked
3315  * rports which would lead to offlined SCSI devices.
3316  *
3317  * Returns: 0 if the fc_rport left the state FC_PORTSTATE_BLOCKED.
3318  *	    FAST_IO_FAIL if the fast_io_fail_tmo fired, this should be
3319  *	    passed back to scsi_eh.
3320  */
3321 int fc_block_scsi_eh(struct scsi_cmnd *cmnd)
3322 {
3323 	struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
3324 
3325 	if (WARN_ON_ONCE(!rport))
3326 		return FAST_IO_FAIL;
3327 
3328 	return fc_block_rport(rport);
3329 }
3330 EXPORT_SYMBOL(fc_block_scsi_eh);
3331 
3332 /**
3333  * fc_vport_setup - allocates and creates a FC virtual port.
3334  * @shost:	scsi host the virtual port is connected to.
3335  * @channel:	Channel on shost port connected to.
3336  * @pdev:	parent device for vport
3337  * @ids:	The world wide names, FC4 port roles, etc for
3338  *              the virtual port.
3339  * @ret_vport:	The pointer to the created vport.
3340  *
3341  * Allocates and creates the vport structure, calls the parent host
3342  * to instantiate the vport, this completes w/ class and sysfs creation.
3343  *
3344  * Notes:
3345  *	This routine assumes no locks are held on entry.
3346  */
3347 static int
3348 fc_vport_setup(struct Scsi_Host *shost, int channel, struct device *pdev,
3349 	struct fc_vport_identifiers  *ids, struct fc_vport **ret_vport)
3350 {
3351 	struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
3352 	struct fc_internal *fci = to_fc_internal(shost->transportt);
3353 	struct fc_vport *vport;
3354 	struct device *dev;
3355 	unsigned long flags;
3356 	size_t size;
3357 	int error;
3358 
3359 	*ret_vport = NULL;
3360 
3361 	if ( ! fci->f->vport_create)
3362 		return -ENOENT;
3363 
3364 	size = (sizeof(struct fc_vport) + fci->f->dd_fcvport_size);
3365 	vport = kzalloc(size, GFP_KERNEL);
3366 	if (unlikely(!vport)) {
3367 		printk(KERN_ERR "%s: allocation failure\n", __func__);
3368 		return -ENOMEM;
3369 	}
3370 
3371 	vport->vport_state = FC_VPORT_UNKNOWN;
3372 	vport->vport_last_state = FC_VPORT_UNKNOWN;
3373 	vport->node_name = ids->node_name;
3374 	vport->port_name = ids->port_name;
3375 	vport->roles = ids->roles;
3376 	vport->vport_type = ids->vport_type;
3377 	if (fci->f->dd_fcvport_size)
3378 		vport->dd_data = &vport[1];
3379 	vport->shost = shost;
3380 	vport->channel = channel;
3381 	vport->flags = FC_VPORT_CREATING;
3382 	INIT_WORK(&vport->vport_delete_work, fc_vport_sched_delete);
3383 
3384 	spin_lock_irqsave(shost->host_lock, flags);
3385 
3386 	if (fc_host->npiv_vports_inuse >= fc_host->max_npiv_vports) {
3387 		spin_unlock_irqrestore(shost->host_lock, flags);
3388 		kfree(vport);
3389 		return -ENOSPC;
3390 	}
3391 	fc_host->npiv_vports_inuse++;
3392 	vport->number = fc_host->next_vport_number++;
3393 	list_add_tail(&vport->peers, &fc_host->vports);
3394 	scsi_host_get(shost);			/* for fc_host->vport list */
3395 
3396 	spin_unlock_irqrestore(shost->host_lock, flags);
3397 
3398 	dev = &vport->dev;
3399 	device_initialize(dev);			/* takes self reference */
3400 	dev->parent = get_device(pdev);		/* takes parent reference */
3401 	dev->release = fc_vport_dev_release;
3402 	dev_set_name(dev, "vport-%d:%d-%d",
3403 		     shost->host_no, channel, vport->number);
3404 	transport_setup_device(dev);
3405 
3406 	error = device_add(dev);
3407 	if (error) {
3408 		printk(KERN_ERR "FC Virtual Port device_add failed\n");
3409 		goto delete_vport;
3410 	}
3411 	transport_add_device(dev);
3412 	transport_configure_device(dev);
3413 
3414 	error = fci->f->vport_create(vport, ids->disable);
3415 	if (error) {
3416 		printk(KERN_ERR "FC Virtual Port LLDD Create failed\n");
3417 		goto delete_vport_all;
3418 	}
3419 
3420 	/*
3421 	 * if the parent isn't the physical adapter's Scsi_Host, ensure
3422 	 * the Scsi_Host at least contains a symlink to the vport.
3423 	 */
3424 	if (pdev != &shost->shost_gendev) {
3425 		error = sysfs_create_link(&shost->shost_gendev.kobj,
3426 				 &dev->kobj, dev_name(dev));
3427 		if (error)
3428 			printk(KERN_ERR
3429 				"%s: Cannot create vport symlinks for "
3430 				"%s, err=%d\n",
3431 				__func__, dev_name(dev), error);
3432 	}
3433 	spin_lock_irqsave(shost->host_lock, flags);
3434 	vport->flags &= ~FC_VPORT_CREATING;
3435 	spin_unlock_irqrestore(shost->host_lock, flags);
3436 
3437 	dev_printk(KERN_NOTICE, pdev,
3438 			"%s created via shost%d channel %d\n", dev_name(dev),
3439 			shost->host_no, channel);
3440 
3441 	*ret_vport = vport;
3442 
3443 	return 0;
3444 
3445 delete_vport_all:
3446 	transport_remove_device(dev);
3447 	device_del(dev);
3448 delete_vport:
3449 	transport_destroy_device(dev);
3450 	spin_lock_irqsave(shost->host_lock, flags);
3451 	list_del(&vport->peers);
3452 	scsi_host_put(shost);			/* for fc_host->vport list */
3453 	fc_host->npiv_vports_inuse--;
3454 	spin_unlock_irqrestore(shost->host_lock, flags);
3455 	put_device(dev->parent);
3456 	kfree(vport);
3457 
3458 	return error;
3459 }
3460 
3461 /**
3462  * fc_vport_create - Admin App or LLDD requests creation of a vport
3463  * @shost:	scsi host the virtual port is connected to.
3464  * @channel:	channel on shost port connected to.
3465  * @ids:	The world wide names, FC4 port roles, etc for
3466  *              the virtual port.
3467  *
3468  * Notes:
3469  *	This routine assumes no locks are held on entry.
3470  */
3471 struct fc_vport *
3472 fc_vport_create(struct Scsi_Host *shost, int channel,
3473 	struct fc_vport_identifiers *ids)
3474 {
3475 	int stat;
3476 	struct fc_vport *vport;
3477 
3478 	stat = fc_vport_setup(shost, channel, &shost->shost_gendev,
3479 		 ids, &vport);
3480 	return stat ? NULL : vport;
3481 }
3482 EXPORT_SYMBOL(fc_vport_create);
3483 
3484 /**
3485  * fc_vport_terminate - Admin App or LLDD requests termination of a vport
3486  * @vport:	fc_vport to be terminated
3487  *
3488  * Calls the LLDD vport_delete() function, then deallocates and removes
3489  * the vport from the shost and object tree.
3490  *
3491  * Notes:
3492  *	This routine assumes no locks are held on entry.
3493  */
3494 int
3495 fc_vport_terminate(struct fc_vport *vport)
3496 {
3497 	struct Scsi_Host *shost = vport_to_shost(vport);
3498 	struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
3499 	struct fc_internal *i = to_fc_internal(shost->transportt);
3500 	struct device *dev = &vport->dev;
3501 	unsigned long flags;
3502 	int stat;
3503 
3504 	if (i->f->vport_delete)
3505 		stat = i->f->vport_delete(vport);
3506 	else
3507 		stat = -ENOENT;
3508 
3509 	spin_lock_irqsave(shost->host_lock, flags);
3510 	vport->flags &= ~FC_VPORT_DELETING;
3511 	if (!stat) {
3512 		vport->flags |= FC_VPORT_DELETED;
3513 		list_del(&vport->peers);
3514 		fc_host->npiv_vports_inuse--;
3515 		scsi_host_put(shost);		/* for fc_host->vport list */
3516 	}
3517 	spin_unlock_irqrestore(shost->host_lock, flags);
3518 
3519 	if (stat)
3520 		return stat;
3521 
3522 	if (dev->parent != &shost->shost_gendev)
3523 		sysfs_remove_link(&shost->shost_gendev.kobj, dev_name(dev));
3524 	transport_remove_device(dev);
3525 	device_del(dev);
3526 	transport_destroy_device(dev);
3527 
3528 	/*
3529 	 * Removing our self-reference should mean our
3530 	 * release function gets called, which will drop the remaining
3531 	 * parent reference and free the data structure.
3532 	 */
3533 	put_device(dev);			/* for self-reference */
3534 
3535 	return 0; /* SUCCESS */
3536 }
3537 EXPORT_SYMBOL(fc_vport_terminate);
3538 
3539 /**
3540  * fc_vport_sched_delete - workq-based delete request for a vport
3541  * @work:	vport to be deleted.
3542  */
3543 static void
3544 fc_vport_sched_delete(struct work_struct *work)
3545 {
3546 	struct fc_vport *vport =
3547 		container_of(work, struct fc_vport, vport_delete_work);
3548 	int stat;
3549 
3550 	stat = fc_vport_terminate(vport);
3551 	if (stat)
3552 		dev_printk(KERN_ERR, vport->dev.parent,
3553 			"%s: %s could not be deleted created via "
3554 			"shost%d channel %d - error %d\n", __func__,
3555 			dev_name(&vport->dev), vport->shost->host_no,
3556 			vport->channel, stat);
3557 }
3558 
3559 
3560 /*
3561  * BSG support
3562  */
3563 
3564 /**
3565  * fc_bsg_job_timeout - handler for when a bsg request timesout
3566  * @req:	request that timed out
3567  */
3568 static enum blk_eh_timer_return
3569 fc_bsg_job_timeout(struct request *req)
3570 {
3571 	struct bsg_job *job = blk_mq_rq_to_pdu(req);
3572 	struct Scsi_Host *shost = fc_bsg_to_shost(job);
3573 	struct fc_rport *rport = fc_bsg_to_rport(job);
3574 	struct fc_internal *i = to_fc_internal(shost->transportt);
3575 	int err = 0, inflight = 0;
3576 
3577 	if (rport && rport->port_state == FC_PORTSTATE_BLOCKED)
3578 		return BLK_EH_RESET_TIMER;
3579 
3580 	inflight = bsg_job_get(job);
3581 
3582 	if (inflight && i->f->bsg_timeout) {
3583 		/* call LLDD to abort the i/o as it has timed out */
3584 		err = i->f->bsg_timeout(job);
3585 		if (err == -EAGAIN) {
3586 			bsg_job_put(job);
3587 			return BLK_EH_RESET_TIMER;
3588 		} else if (err)
3589 			printk(KERN_ERR "ERROR: FC BSG request timeout - LLD "
3590 				"abort failed with status %d\n", err);
3591 	}
3592 
3593 	/* the blk_end_sync_io() doesn't check the error */
3594 	if (inflight)
3595 		__blk_complete_request(req);
3596 	return BLK_EH_DONE;
3597 }
3598 
3599 /**
3600  * fc_bsg_host_dispatch - process fc host bsg requests and dispatch to LLDD
3601  * @shost:	scsi host rport attached to
3602  * @job:	bsg job to be processed
3603  */
3604 static int fc_bsg_host_dispatch(struct Scsi_Host *shost, struct bsg_job *job)
3605 {
3606 	struct fc_internal *i = to_fc_internal(shost->transportt);
3607 	struct fc_bsg_request *bsg_request = job->request;
3608 	struct fc_bsg_reply *bsg_reply = job->reply;
3609 	int cmdlen = sizeof(uint32_t);	/* start with length of msgcode */
3610 	int ret;
3611 
3612 	/* check if we really have all the request data needed */
3613 	if (job->request_len < cmdlen) {
3614 		ret = -ENOMSG;
3615 		goto fail_host_msg;
3616 	}
3617 
3618 	/* Validate the host command */
3619 	switch (bsg_request->msgcode) {
3620 	case FC_BSG_HST_ADD_RPORT:
3621 		cmdlen += sizeof(struct fc_bsg_host_add_rport);
3622 		break;
3623 
3624 	case FC_BSG_HST_DEL_RPORT:
3625 		cmdlen += sizeof(struct fc_bsg_host_del_rport);
3626 		break;
3627 
3628 	case FC_BSG_HST_ELS_NOLOGIN:
3629 		cmdlen += sizeof(struct fc_bsg_host_els);
3630 		/* there better be a xmt and rcv payloads */
3631 		if ((!job->request_payload.payload_len) ||
3632 		    (!job->reply_payload.payload_len)) {
3633 			ret = -EINVAL;
3634 			goto fail_host_msg;
3635 		}
3636 		break;
3637 
3638 	case FC_BSG_HST_CT:
3639 		cmdlen += sizeof(struct fc_bsg_host_ct);
3640 		/* there better be xmt and rcv payloads */
3641 		if ((!job->request_payload.payload_len) ||
3642 		    (!job->reply_payload.payload_len)) {
3643 			ret = -EINVAL;
3644 			goto fail_host_msg;
3645 		}
3646 		break;
3647 
3648 	case FC_BSG_HST_VENDOR:
3649 		cmdlen += sizeof(struct fc_bsg_host_vendor);
3650 		if ((shost->hostt->vendor_id == 0L) ||
3651 		    (bsg_request->rqst_data.h_vendor.vendor_id !=
3652 			shost->hostt->vendor_id)) {
3653 			ret = -ESRCH;
3654 			goto fail_host_msg;
3655 		}
3656 		break;
3657 
3658 	default:
3659 		ret = -EBADR;
3660 		goto fail_host_msg;
3661 	}
3662 
3663 	ret = i->f->bsg_request(job);
3664 	if (!ret)
3665 		return 0;
3666 
3667 fail_host_msg:
3668 	/* return the errno failure code as the only status */
3669 	BUG_ON(job->reply_len < sizeof(uint32_t));
3670 	bsg_reply->reply_payload_rcv_len = 0;
3671 	bsg_reply->result = ret;
3672 	job->reply_len = sizeof(uint32_t);
3673 	bsg_job_done(job, bsg_reply->result,
3674 		       bsg_reply->reply_payload_rcv_len);
3675 	return 0;
3676 }
3677 
3678 
3679 /*
3680  * fc_bsg_goose_queue - restart rport queue in case it was stopped
3681  * @rport:	rport to be restarted
3682  */
3683 static void
3684 fc_bsg_goose_queue(struct fc_rport *rport)
3685 {
3686 	struct request_queue *q = rport->rqst_q;
3687 	unsigned long flags;
3688 
3689 	if (!q)
3690 		return;
3691 
3692 	spin_lock_irqsave(q->queue_lock, flags);
3693 	blk_run_queue_async(q);
3694 	spin_unlock_irqrestore(q->queue_lock, flags);
3695 }
3696 
3697 /**
3698  * fc_bsg_rport_dispatch - process rport bsg requests and dispatch to LLDD
3699  * @shost:	scsi host rport attached to
3700  * @job:	bsg job to be processed
3701  */
3702 static int fc_bsg_rport_dispatch(struct Scsi_Host *shost, struct bsg_job *job)
3703 {
3704 	struct fc_internal *i = to_fc_internal(shost->transportt);
3705 	struct fc_bsg_request *bsg_request = job->request;
3706 	struct fc_bsg_reply *bsg_reply = job->reply;
3707 	int cmdlen = sizeof(uint32_t);	/* start with length of msgcode */
3708 	int ret;
3709 
3710 	/* check if we really have all the request data needed */
3711 	if (job->request_len < cmdlen) {
3712 		ret = -ENOMSG;
3713 		goto fail_rport_msg;
3714 	}
3715 
3716 	/* Validate the rport command */
3717 	switch (bsg_request->msgcode) {
3718 	case FC_BSG_RPT_ELS:
3719 		cmdlen += sizeof(struct fc_bsg_rport_els);
3720 		goto check_bidi;
3721 
3722 	case FC_BSG_RPT_CT:
3723 		cmdlen += sizeof(struct fc_bsg_rport_ct);
3724 check_bidi:
3725 		/* there better be xmt and rcv payloads */
3726 		if ((!job->request_payload.payload_len) ||
3727 		    (!job->reply_payload.payload_len)) {
3728 			ret = -EINVAL;
3729 			goto fail_rport_msg;
3730 		}
3731 		break;
3732 	default:
3733 		ret = -EBADR;
3734 		goto fail_rport_msg;
3735 	}
3736 
3737 	ret = i->f->bsg_request(job);
3738 	if (!ret)
3739 		return 0;
3740 
3741 fail_rport_msg:
3742 	/* return the errno failure code as the only status */
3743 	BUG_ON(job->reply_len < sizeof(uint32_t));
3744 	bsg_reply->reply_payload_rcv_len = 0;
3745 	bsg_reply->result = ret;
3746 	job->reply_len = sizeof(uint32_t);
3747 	bsg_job_done(job, bsg_reply->result,
3748 		       bsg_reply->reply_payload_rcv_len);
3749 	return 0;
3750 }
3751 
3752 static int fc_bsg_dispatch(struct bsg_job *job)
3753 {
3754 	struct Scsi_Host *shost = fc_bsg_to_shost(job);
3755 
3756 	if (scsi_is_fc_rport(job->dev))
3757 		return fc_bsg_rport_dispatch(shost, job);
3758 	else
3759 		return fc_bsg_host_dispatch(shost, job);
3760 }
3761 
3762 /**
3763  * fc_bsg_hostadd - Create and add the bsg hooks so we can receive requests
3764  * @shost:	shost for fc_host
3765  * @fc_host:	fc_host adding the structures to
3766  */
3767 static int
3768 fc_bsg_hostadd(struct Scsi_Host *shost, struct fc_host_attrs *fc_host)
3769 {
3770 	struct device *dev = &shost->shost_gendev;
3771 	struct fc_internal *i = to_fc_internal(shost->transportt);
3772 	struct request_queue *q;
3773 	char bsg_name[20];
3774 
3775 	fc_host->rqst_q = NULL;
3776 
3777 	if (!i->f->bsg_request)
3778 		return -ENOTSUPP;
3779 
3780 	snprintf(bsg_name, sizeof(bsg_name),
3781 		 "fc_host%d", shost->host_no);
3782 
3783 	q = bsg_setup_queue(dev, bsg_name, fc_bsg_dispatch, i->f->dd_bsg_size);
3784 	if (IS_ERR(q)) {
3785 		dev_err(dev,
3786 			"fc_host%d: bsg interface failed to initialize - setup queue\n",
3787 			shost->host_no);
3788 		return PTR_ERR(q);
3789 	}
3790 	__scsi_init_queue(shost, q);
3791 	blk_queue_rq_timed_out(q, fc_bsg_job_timeout);
3792 	blk_queue_rq_timeout(q, FC_DEFAULT_BSG_TIMEOUT);
3793 	fc_host->rqst_q = q;
3794 	return 0;
3795 }
3796 
3797 static int fc_bsg_rport_prep(struct request_queue *q, struct request *req)
3798 {
3799 	struct fc_rport *rport = dev_to_rport(q->queuedata);
3800 
3801 	if (rport->port_state == FC_PORTSTATE_BLOCKED &&
3802 	    !(rport->flags & FC_RPORT_FAST_FAIL_TIMEDOUT))
3803 		return BLKPREP_DEFER;
3804 
3805 	if (rport->port_state != FC_PORTSTATE_ONLINE)
3806 		return BLKPREP_KILL;
3807 
3808 	return BLKPREP_OK;
3809 }
3810 
3811 /**
3812  * fc_bsg_rportadd - Create and add the bsg hooks so we can receive requests
3813  * @shost:	shost that rport is attached to
3814  * @rport:	rport that the bsg hooks are being attached to
3815  */
3816 static int
3817 fc_bsg_rportadd(struct Scsi_Host *shost, struct fc_rport *rport)
3818 {
3819 	struct device *dev = &rport->dev;
3820 	struct fc_internal *i = to_fc_internal(shost->transportt);
3821 	struct request_queue *q;
3822 
3823 	rport->rqst_q = NULL;
3824 
3825 	if (!i->f->bsg_request)
3826 		return -ENOTSUPP;
3827 
3828 	q = bsg_setup_queue(dev, dev_name(dev), fc_bsg_dispatch,
3829 			i->f->dd_bsg_size);
3830 	if (IS_ERR(q)) {
3831 		dev_err(dev, "failed to setup bsg queue\n");
3832 		return PTR_ERR(q);
3833 	}
3834 	__scsi_init_queue(shost, q);
3835 	blk_queue_prep_rq(q, fc_bsg_rport_prep);
3836 	blk_queue_rq_timed_out(q, fc_bsg_job_timeout);
3837 	blk_queue_rq_timeout(q, BLK_DEFAULT_SG_TIMEOUT);
3838 	rport->rqst_q = q;
3839 	return 0;
3840 }
3841 
3842 
3843 /**
3844  * fc_bsg_remove - Deletes the bsg hooks on fchosts/rports
3845  * @q:	the request_queue that is to be torn down.
3846  *
3847  * Notes:
3848  *   Before unregistering the queue empty any requests that are blocked
3849  *
3850  *
3851  */
3852 static void
3853 fc_bsg_remove(struct request_queue *q)
3854 {
3855 	if (q) {
3856 		bsg_unregister_queue(q);
3857 		blk_cleanup_queue(q);
3858 	}
3859 }
3860 
3861 
3862 /* Original Author:  Martin Hicks */
3863 MODULE_AUTHOR("James Smart");
3864 MODULE_DESCRIPTION("FC Transport Attributes");
3865 MODULE_LICENSE("GPL");
3866 
3867 module_init(fc_transport_init);
3868 module_exit(fc_transport_exit);
3869