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