drivers/scsi/scsi_transport_fc.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  FiberChannel transport specific attributes exported to sysfs.
0004  *
0005  *  Copyright (c) 2003 Silicon Graphics, Inc.  All rights reserved.
0006  *  Copyright (C) 2004-2007   James Smart, Emulex Corporation
0007  *    Rewrite for host, target, device, and remote port attributes,
0008  *    statistics, and service functions...
0009  *    Add vports, etc
0010  */
0011 #include <linux/module.h>
0012 #include <linux/init.h>
0013 #include <linux/slab.h>
0014 #include <linux/delay.h>
0015 #include <linux/kernel.h>
0016 #include <linux/bsg-lib.h>
0017 #include <scsi/scsi_device.h>
0018 #include <scsi/scsi_host.h>
0019 #include <scsi/scsi_transport.h>
0020 #include <scsi/scsi_transport_fc.h>
0021 #include <scsi/scsi_cmnd.h>
0022 #include <net/netlink.h>
0023 #include <scsi/scsi_netlink_fc.h>
0024 #include <scsi/scsi_bsg_fc.h>
0025 #include <uapi/scsi/fc/fc_els.h>
0026 #include "scsi_priv.h"
0027
0028 static int fc_queue_work(struct Scsi_Host *, struct work_struct *);
0029 static void fc_vport_sched_delete(struct work_struct *work);
0030 static int fc_vport_setup(struct Scsi_Host *shost, int channel,
0031     struct device *pdev, struct fc_vport_identifiers  *ids,
0032     struct fc_vport **vport);
0033 static int fc_bsg_hostadd(struct Scsi_Host *, struct fc_host_attrs *);
0034 static int fc_bsg_rportadd(struct Scsi_Host *, struct fc_rport *);
0035 static void fc_bsg_remove(struct request_queue *);
0036 static void fc_bsg_goose_queue(struct fc_rport *);
0037 static void fc_li_stats_update(u16 event_type,
0038                    struct fc_fpin_stats *stats);
0039 static void fc_delivery_stats_update(u32 reason_code,
0040                      struct fc_fpin_stats *stats);
0041 static void fc_cn_stats_update(u16 event_type, struct fc_fpin_stats *stats);
0042
0043 /*
0044  * Module Parameters
0045  */
0046
0047 /*
0048  * dev_loss_tmo: the default number of seconds that the FC transport
0049  *   should insulate the loss of a remote port.
0050  *   The maximum will be capped by the value of SCSI_DEVICE_BLOCK_MAX_TIMEOUT.
0051  */
0052 static unsigned int fc_dev_loss_tmo = 60;       /* seconds */
0053
0054 module_param_named(dev_loss_tmo, fc_dev_loss_tmo, uint, S_IRUGO|S_IWUSR);
0055 MODULE_PARM_DESC(dev_loss_tmo,
0056          "Maximum number of seconds that the FC transport should"
0057          " insulate the loss of a remote port. Once this value is"
0058          " exceeded, the scsi target is removed. Value should be"
0059          " between 1 and SCSI_DEVICE_BLOCK_MAX_TIMEOUT if"
0060          " fast_io_fail_tmo is not set.");
0061
0062 /*
0063  * Redefine so that we can have same named attributes in the
0064  * sdev/starget/host objects.
0065  */
0066 #define FC_DEVICE_ATTR(_prefix,_name,_mode,_show,_store)        \
0067 struct device_attribute device_attr_##_prefix##_##_name =   \
0068     __ATTR(_name,_mode,_show,_store)
0069
0070 #define fc_enum_name_search(title, table_type, table)           \
0071 static const char *get_fc_##title##_name(enum table_type table_key) \
0072 {                                   \
0073     int i;                              \
0074     char *name = NULL;                      \
0075                                     \
0076     for (i = 0; i < ARRAY_SIZE(table); i++) {           \
0077         if (table[i].value == table_key) {          \
0078             name = table[i].name;               \
0079             break;                      \
0080         }                           \
0081     }                               \
0082     return name;                            \
0083 }
0084
0085 #define fc_enum_name_match(title, table_type, table)            \
0086 static int get_fc_##title##_match(const char *table_key,        \
0087         enum table_type *value)                 \
0088 {                                   \
0089     int i;                              \
0090                                     \
0091     for (i = 0; i < ARRAY_SIZE(table); i++) {           \
0092         if (strncmp(table_key, table[i].name,           \
0093                 table[i].matchlen) == 0) {      \
0094             *value = table[i].value;            \
0095             return 0; /* success */             \
0096         }                           \
0097     }                               \
0098     return 1; /* failure */                     \
0099 }
0100
0101
0102 /* Convert fc_port_type values to ascii string name */
0103 static struct {
0104     enum fc_port_type   value;
0105     char            *name;
0106 } fc_port_type_names[] = {
0107     { FC_PORTTYPE_UNKNOWN,      "Unknown" },
0108     { FC_PORTTYPE_OTHER,        "Other" },
0109     { FC_PORTTYPE_NOTPRESENT,   "Not Present" },
0110     { FC_PORTTYPE_NPORT,    "NPort (fabric via point-to-point)" },
0111     { FC_PORTTYPE_NLPORT,   "NLPort (fabric via loop)" },
0112     { FC_PORTTYPE_LPORT,    "LPort (private loop)" },
0113     { FC_PORTTYPE_PTP,  "Point-To-Point (direct nport connection)" },
0114     { FC_PORTTYPE_NPIV,     "NPIV VPORT" },
0115 };
0116 fc_enum_name_search(port_type, fc_port_type, fc_port_type_names)
0117 #define FC_PORTTYPE_MAX_NAMELEN     50
0118
0119 /* Reuse fc_port_type enum function for vport_type */
0120 #define get_fc_vport_type_name get_fc_port_type_name
0121
0122
0123 /* Convert fc_host_event_code values to ascii string name */
0124 static const struct {
0125     enum fc_host_event_code     value;
0126     char                *name;
0127 } fc_host_event_code_names[] = {
0128     { FCH_EVT_LIP,          "lip" },
0129     { FCH_EVT_LINKUP,       "link_up" },
0130     { FCH_EVT_LINKDOWN,     "link_down" },
0131     { FCH_EVT_LIPRESET,     "lip_reset" },
0132     { FCH_EVT_RSCN,         "rscn" },
0133     { FCH_EVT_ADAPTER_CHANGE,   "adapter_chg" },
0134     { FCH_EVT_PORT_UNKNOWN,     "port_unknown" },
0135     { FCH_EVT_PORT_ONLINE,      "port_online" },
0136     { FCH_EVT_PORT_OFFLINE,     "port_offline" },
0137     { FCH_EVT_PORT_FABRIC,      "port_fabric" },
0138     { FCH_EVT_LINK_UNKNOWN,     "link_unknown" },
0139     { FCH_EVT_LINK_FPIN,        "link_FPIN" },
0140     { FCH_EVT_VENDOR_UNIQUE,    "vendor_unique" },
0141 };
0142 fc_enum_name_search(host_event_code, fc_host_event_code,
0143         fc_host_event_code_names)
0144 #define FC_HOST_EVENT_CODE_MAX_NAMELEN  30
0145
0146
0147 /* Convert fc_port_state values to ascii string name */
0148 static struct {
0149     enum fc_port_state  value;
0150     char            *name;
0151     int         matchlen;
0152 } fc_port_state_names[] = {
0153     { FC_PORTSTATE_UNKNOWN,     "Unknown", 7},
0154     { FC_PORTSTATE_NOTPRESENT,  "Not Present", 11 },
0155     { FC_PORTSTATE_ONLINE,      "Online", 6 },
0156     { FC_PORTSTATE_OFFLINE,     "Offline", 7 },
0157     { FC_PORTSTATE_BLOCKED,     "Blocked", 7 },
0158     { FC_PORTSTATE_BYPASSED,    "Bypassed", 8 },
0159     { FC_PORTSTATE_DIAGNOSTICS, "Diagnostics", 11 },
0160     { FC_PORTSTATE_LINKDOWN,    "Linkdown", 8 },
0161     { FC_PORTSTATE_ERROR,       "Error", 5 },
0162     { FC_PORTSTATE_LOOPBACK,    "Loopback", 8 },
0163     { FC_PORTSTATE_DELETED,     "Deleted", 7 },
0164     { FC_PORTSTATE_MARGINAL,    "Marginal", 8 },
0165 };
0166 fc_enum_name_search(port_state, fc_port_state, fc_port_state_names)
0167 fc_enum_name_match(port_state, fc_port_state, fc_port_state_names)
0168 #define FC_PORTSTATE_MAX_NAMELEN    20
0169
0170
0171 /* Convert fc_vport_state values to ascii string name */
0172 static struct {
0173     enum fc_vport_state value;
0174     char            *name;
0175 } fc_vport_state_names[] = {
0176     { FC_VPORT_UNKNOWN,     "Unknown" },
0177     { FC_VPORT_ACTIVE,      "Active" },
0178     { FC_VPORT_DISABLED,        "Disabled" },
0179     { FC_VPORT_LINKDOWN,        "Linkdown" },
0180     { FC_VPORT_INITIALIZING,    "Initializing" },
0181     { FC_VPORT_NO_FABRIC_SUPP,  "No Fabric Support" },
0182     { FC_VPORT_NO_FABRIC_RSCS,  "No Fabric Resources" },
0183     { FC_VPORT_FABRIC_LOGOUT,   "Fabric Logout" },
0184     { FC_VPORT_FABRIC_REJ_WWN,  "Fabric Rejected WWN" },
0185     { FC_VPORT_FAILED,      "VPort Failed" },
0186 };
0187 fc_enum_name_search(vport_state, fc_vport_state, fc_vport_state_names)
0188 #define FC_VPORTSTATE_MAX_NAMELEN   24
0189
0190 /* Reuse fc_vport_state enum function for vport_last_state */
0191 #define get_fc_vport_last_state_name get_fc_vport_state_name
0192
0193
0194 /* Convert fc_tgtid_binding_type values to ascii string name */
0195 static const struct {
0196     enum fc_tgtid_binding_type  value;
0197     char                *name;
0198     int             matchlen;
0199 } fc_tgtid_binding_type_names[] = {
0200     { FC_TGTID_BIND_NONE, "none", 4 },
0201     { FC_TGTID_BIND_BY_WWPN, "wwpn (World Wide Port Name)", 4 },
0202     { FC_TGTID_BIND_BY_WWNN, "wwnn (World Wide Node Name)", 4 },
0203     { FC_TGTID_BIND_BY_ID, "port_id (FC Address)", 7 },
0204 };
0205 fc_enum_name_search(tgtid_bind_type, fc_tgtid_binding_type,
0206         fc_tgtid_binding_type_names)
0207 fc_enum_name_match(tgtid_bind_type, fc_tgtid_binding_type,
0208         fc_tgtid_binding_type_names)
0209 #define FC_BINDTYPE_MAX_NAMELEN 30
0210
0211
0212 #define fc_bitfield_name_search(title, table)           \
0213 static ssize_t                          \
0214 get_fc_##title##_names(u32 table_key, char *buf)        \
0215 {                               \
0216     char *prefix = "";                  \
0217     ssize_t len = 0;                    \
0218     int i;                          \
0219                                 \
0220     for (i = 0; i < ARRAY_SIZE(table); i++) {       \
0221         if (table[i].value & table_key) {       \
0222             len += sprintf(buf + len, "%s%s",   \
0223                 prefix, table[i].name);     \
0224             prefix = ", ";              \
0225         }                       \
0226     }                           \
0227     len += sprintf(buf + len, "\n");            \
0228     return len;                     \
0229 }
0230
0231
0232 /* Convert FC_COS bit values to ascii string name */
0233 static const struct {
0234     u32             value;
0235     char            *name;
0236 } fc_cos_names[] = {
0237     { FC_COS_CLASS1,    "Class 1" },
0238     { FC_COS_CLASS2,    "Class 2" },
0239     { FC_COS_CLASS3,    "Class 3" },
0240     { FC_COS_CLASS4,    "Class 4" },
0241     { FC_COS_CLASS6,    "Class 6" },
0242 };
0243 fc_bitfield_name_search(cos, fc_cos_names)
0244
0245
0246 /* Convert FC_PORTSPEED bit values to ascii string name */
0247 static const struct {
0248     u32             value;
0249     char            *name;
0250 } fc_port_speed_names[] = {
0251     { FC_PORTSPEED_1GBIT,       "1 Gbit" },
0252     { FC_PORTSPEED_2GBIT,       "2 Gbit" },
0253     { FC_PORTSPEED_4GBIT,       "4 Gbit" },
0254     { FC_PORTSPEED_10GBIT,      "10 Gbit" },
0255     { FC_PORTSPEED_8GBIT,       "8 Gbit" },
0256     { FC_PORTSPEED_16GBIT,      "16 Gbit" },
0257     { FC_PORTSPEED_32GBIT,      "32 Gbit" },
0258     { FC_PORTSPEED_20GBIT,      "20 Gbit" },
0259     { FC_PORTSPEED_40GBIT,      "40 Gbit" },
0260     { FC_PORTSPEED_50GBIT,      "50 Gbit" },
0261     { FC_PORTSPEED_100GBIT,     "100 Gbit" },
0262     { FC_PORTSPEED_25GBIT,      "25 Gbit" },
0263     { FC_PORTSPEED_64GBIT,      "64 Gbit" },
0264     { FC_PORTSPEED_128GBIT,     "128 Gbit" },
0265     { FC_PORTSPEED_256GBIT,     "256 Gbit" },
0266     { FC_PORTSPEED_NOT_NEGOTIATED,  "Not Negotiated" },
0267 };
0268 fc_bitfield_name_search(port_speed, fc_port_speed_names)
0269
0270
0271 static int
0272 show_fc_fc4s (char *buf, u8 *fc4_list)
0273 {
0274     int i, len=0;
0275
0276     for (i = 0; i < FC_FC4_LIST_SIZE; i++, fc4_list++)
0277         len += sprintf(buf + len , "0x%02x ", *fc4_list);
0278     len += sprintf(buf + len, "\n");
0279     return len;
0280 }
0281
0282
0283 /* Convert FC_PORT_ROLE bit values to ascii string name */
0284 static const struct {
0285     u32             value;
0286     char            *name;
0287 } fc_port_role_names[] = {
0288     { FC_PORT_ROLE_FCP_TARGET,      "FCP Target" },
0289     { FC_PORT_ROLE_FCP_INITIATOR,       "FCP Initiator" },
0290     { FC_PORT_ROLE_IP_PORT,         "IP Port" },
0291     { FC_PORT_ROLE_FCP_DUMMY_INITIATOR, "FCP Dummy Initiator" },
0292     { FC_PORT_ROLE_NVME_INITIATOR,      "NVMe Initiator" },
0293     { FC_PORT_ROLE_NVME_TARGET,     "NVMe Target" },
0294     { FC_PORT_ROLE_NVME_DISCOVERY,      "NVMe Discovery" },
0295 };
0296 fc_bitfield_name_search(port_roles, fc_port_role_names)
0297
0298 /*
0299  * Define roles that are specific to port_id. Values are relative to ROLE_MASK.
0300  */
0301 #define FC_WELLKNOWN_PORTID_MASK    0xfffff0
0302 #define FC_WELLKNOWN_ROLE_MASK      0x00000f
0303 #define FC_FPORT_PORTID         0x00000e
0304 #define FC_FABCTLR_PORTID       0x00000d
0305 #define FC_DIRSRVR_PORTID       0x00000c
0306 #define FC_TIMESRVR_PORTID      0x00000b
0307 #define FC_MGMTSRVR_PORTID      0x00000a
0308
0309
0310 static void fc_timeout_deleted_rport(struct work_struct *work);
0311 static void fc_timeout_fail_rport_io(struct work_struct *work);
0312 static void fc_scsi_scan_rport(struct work_struct *work);
0313
0314 /*
0315  * Attribute counts pre object type...
0316  * Increase these values if you add attributes
0317  */
0318 #define FC_STARGET_NUM_ATTRS    3
0319 #define FC_RPORT_NUM_ATTRS  10
0320 #define FC_VPORT_NUM_ATTRS  9
0321 #define FC_HOST_NUM_ATTRS   29
0322
0323 struct fc_internal {
0324     struct scsi_transport_template t;
0325     struct fc_function_template *f;
0326
0327     /*
0328      * For attributes : each object has :
0329      *   An array of the actual attributes structures
0330      *   An array of null-terminated pointers to the attribute
0331      *     structures - used for mid-layer interaction.
0332      *
0333      * The attribute containers for the starget and host are are
0334      * part of the midlayer. As the remote port is specific to the
0335      * fc transport, we must provide the attribute container.
0336      */
0337     struct device_attribute private_starget_attrs[
0338                             FC_STARGET_NUM_ATTRS];
0339     struct device_attribute *starget_attrs[FC_STARGET_NUM_ATTRS + 1];
0340
0341     struct device_attribute private_host_attrs[FC_HOST_NUM_ATTRS];
0342     struct device_attribute *host_attrs[FC_HOST_NUM_ATTRS + 1];
0343
0344     struct transport_container rport_attr_cont;
0345     struct device_attribute private_rport_attrs[FC_RPORT_NUM_ATTRS];
0346     struct device_attribute *rport_attrs[FC_RPORT_NUM_ATTRS + 1];
0347
0348     struct transport_container vport_attr_cont;
0349     struct device_attribute private_vport_attrs[FC_VPORT_NUM_ATTRS];
0350     struct device_attribute *vport_attrs[FC_VPORT_NUM_ATTRS + 1];
0351 };
0352
0353 #define to_fc_internal(tmpl)    container_of(tmpl, struct fc_internal, t)
0354
0355 static int fc_target_setup(struct transport_container *tc, struct device *dev,
0356                struct device *cdev)
0357 {
0358     struct scsi_target *starget = to_scsi_target(dev);
0359     struct fc_rport *rport = starget_to_rport(starget);
0360
0361     /*
0362      * if parent is remote port, use values from remote port.
0363      * Otherwise, this host uses the fc_transport, but not the
0364      * remote port interface. As such, initialize to known non-values.
0365      */
0366     if (rport) {
0367         fc_starget_node_name(starget) = rport->node_name;
0368         fc_starget_port_name(starget) = rport->port_name;
0369         fc_starget_port_id(starget) = rport->port_id;
0370     } else {
0371         fc_starget_node_name(starget) = -1;
0372         fc_starget_port_name(starget) = -1;
0373         fc_starget_port_id(starget) = -1;
0374     }
0375
0376     return 0;
0377 }
0378
0379 static DECLARE_TRANSPORT_CLASS(fc_transport_class,
0380                    "fc_transport",
0381                    fc_target_setup,
0382                    NULL,
0383                    NULL);
0384
0385 static int fc_host_setup(struct transport_container *tc, struct device *dev,
0386              struct device *cdev)
0387 {
0388     struct Scsi_Host *shost = dev_to_shost(dev);
0389     struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
0390
0391     /*
0392      * Set default values easily detected by the midlayer as
0393      * failure cases.  The scsi lldd is responsible for initializing
0394      * all transport attributes to valid values per host.
0395      */
0396     fc_host->node_name = -1;
0397     fc_host->port_name = -1;
0398     fc_host->permanent_port_name = -1;
0399     fc_host->supported_classes = FC_COS_UNSPECIFIED;
0400     memset(fc_host->supported_fc4s, 0,
0401         sizeof(fc_host->supported_fc4s));
0402     fc_host->supported_speeds = FC_PORTSPEED_UNKNOWN;
0403     fc_host->maxframe_size = -1;
0404     fc_host->max_npiv_vports = 0;
0405     memset(fc_host->serial_number, 0,
0406         sizeof(fc_host->serial_number));
0407     memset(fc_host->manufacturer, 0,
0408         sizeof(fc_host->manufacturer));
0409     memset(fc_host->model, 0,
0410         sizeof(fc_host->model));
0411     memset(fc_host->model_description, 0,
0412         sizeof(fc_host->model_description));
0413     memset(fc_host->hardware_version, 0,
0414         sizeof(fc_host->hardware_version));
0415     memset(fc_host->driver_version, 0,
0416         sizeof(fc_host->driver_version));
0417     memset(fc_host->firmware_version, 0,
0418         sizeof(fc_host->firmware_version));
0419     memset(fc_host->optionrom_version, 0,
0420         sizeof(fc_host->optionrom_version));
0421
0422     fc_host->port_id = -1;
0423     fc_host->port_type = FC_PORTTYPE_UNKNOWN;
0424     fc_host->port_state = FC_PORTSTATE_UNKNOWN;
0425     memset(fc_host->active_fc4s, 0,
0426         sizeof(fc_host->active_fc4s));
0427     fc_host->speed = FC_PORTSPEED_UNKNOWN;
0428     fc_host->fabric_name = -1;
0429     memset(fc_host->symbolic_name, 0, sizeof(fc_host->symbolic_name));
0430     memset(fc_host->system_hostname, 0, sizeof(fc_host->system_hostname));
0431     memset(&fc_host->fpin_stats, 0, sizeof(fc_host->fpin_stats));
0432
0433     fc_host->tgtid_bind_type = FC_TGTID_BIND_BY_WWPN;
0434
0435     INIT_LIST_HEAD(&fc_host->rports);
0436     INIT_LIST_HEAD(&fc_host->rport_bindings);
0437     INIT_LIST_HEAD(&fc_host->vports);
0438     fc_host->next_rport_number = 0;
0439     fc_host->next_target_id = 0;
0440     fc_host->next_vport_number = 0;
0441     fc_host->npiv_vports_inuse = 0;
0442
0443     snprintf(fc_host->work_q_name, sizeof(fc_host->work_q_name),
0444          "fc_wq_%d", shost->host_no);
0445     fc_host->work_q = alloc_workqueue("%s", 0, 0, fc_host->work_q_name);
0446     if (!fc_host->work_q)
0447         return -ENOMEM;
0448
0449     fc_host->dev_loss_tmo = fc_dev_loss_tmo;
0450     snprintf(fc_host->devloss_work_q_name,
0451          sizeof(fc_host->devloss_work_q_name),
0452          "fc_dl_%d", shost->host_no);
0453     fc_host->devloss_work_q = alloc_workqueue("%s", 0, 0,
0454                     fc_host->devloss_work_q_name);
0455     if (!fc_host->devloss_work_q) {
0456         destroy_workqueue(fc_host->work_q);
0457         fc_host->work_q = NULL;
0458         return -ENOMEM;
0459     }
0460
0461     fc_bsg_hostadd(shost, fc_host);
0462     /* ignore any bsg add error - we just can't do sgio */
0463
0464     return 0;
0465 }
0466
0467 static int fc_host_remove(struct transport_container *tc, struct device *dev,
0468              struct device *cdev)
0469 {
0470     struct Scsi_Host *shost = dev_to_shost(dev);
0471     struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
0472
0473     fc_bsg_remove(fc_host->rqst_q);
0474     return 0;
0475 }
0476
0477 static DECLARE_TRANSPORT_CLASS(fc_host_class,
0478                    "fc_host",
0479                    fc_host_setup,
0480                    fc_host_remove,
0481                    NULL);
0482
0483 /*
0484  * Setup and Remove actions for remote ports are handled
0485  * in the service functions below.
0486  */
0487 static DECLARE_TRANSPORT_CLASS(fc_rport_class,
0488                    "fc_remote_ports",
0489                    NULL,
0490                    NULL,
0491                    NULL);
0492
0493 /*
0494  * Setup and Remove actions for virtual ports are handled
0495  * in the service functions below.
0496  */
0497 static DECLARE_TRANSPORT_CLASS(fc_vport_class,
0498                    "fc_vports",
0499                    NULL,
0500                    NULL,
0501                    NULL);
0502
0503 /*
0504  * Netlink Infrastructure
0505  */
0506
0507 static atomic_t fc_event_seq;
0508
0509 /**
0510  * fc_get_event_number - Obtain the next sequential FC event number
0511  *
0512  * Notes:
0513  *   We could have inlined this, but it would have required fc_event_seq to
0514  *   be exposed. For now, live with the subroutine call.
0515  *   Atomic used to avoid lock/unlock...
0516  */
0517 u32
0518 fc_get_event_number(void)
0519 {
0520     return atomic_add_return(1, &fc_event_seq);
0521 }
0522 EXPORT_SYMBOL(fc_get_event_number);
0523
0524 /**
0525  * fc_host_post_fc_event - routine to do the work of posting an event
0526  *                      on an fc_host.
0527  * @shost:      host the event occurred on
0528  * @event_number:   fc event number obtained from get_fc_event_number()
0529  * @event_code:     fc_host event being posted
0530  * @data_len:       amount, in bytes, of event data
0531  * @data_buf:       pointer to event data
0532  * @vendor_id:          value for Vendor id
0533  *
0534  * Notes:
0535  *  This routine assumes no locks are held on entry.
0536  */
0537 void
0538 fc_host_post_fc_event(struct Scsi_Host *shost, u32 event_number,
0539         enum fc_host_event_code event_code,
0540         u32 data_len, char *data_buf, u64 vendor_id)
0541 {
0542     struct sk_buff *skb;
0543     struct nlmsghdr *nlh;
0544     struct fc_nl_event *event;
0545     const char *name;
0546     u32 len;
0547     int err;
0548
0549     if (!data_buf || data_len < 4)
0550         data_len = 0;
0551
0552     if (!scsi_nl_sock) {
0553         err = -ENOENT;
0554         goto send_fail;
0555     }
0556
0557     len = FC_NL_MSGALIGN(sizeof(*event) + data_len);
0558
0559     skb = nlmsg_new(len, GFP_KERNEL);
0560     if (!skb) {
0561         err = -ENOBUFS;
0562         goto send_fail;
0563     }
0564
0565     nlh = nlmsg_put(skb, 0, 0, SCSI_TRANSPORT_MSG, len, 0);
0566     if (!nlh) {
0567         err = -ENOBUFS;
0568         goto send_fail_skb;
0569     }
0570     event = nlmsg_data(nlh);
0571
0572     INIT_SCSI_NL_HDR(&event->snlh, SCSI_NL_TRANSPORT_FC,
0573                 FC_NL_ASYNC_EVENT, len);
0574     event->seconds = ktime_get_real_seconds();
0575     event->vendor_id = vendor_id;
0576     event->host_no = shost->host_no;
0577     event->event_datalen = data_len;    /* bytes */
0578     event->event_num = event_number;
0579     event->event_code = event_code;
0580     if (data_len)
0581         memcpy(&event->event_data, data_buf, data_len);
0582
0583     nlmsg_multicast(scsi_nl_sock, skb, 0, SCSI_NL_GRP_FC_EVENTS,
0584             GFP_KERNEL);
0585     return;
0586
0587 send_fail_skb:
0588     kfree_skb(skb);
0589 send_fail:
0590     name = get_fc_host_event_code_name(event_code);
0591     printk(KERN_WARNING
0592         "%s: Dropped Event : host %d %s data 0x%08x - err %d\n",
0593         __func__, shost->host_no,
0594         (name) ? name : "<unknown>",
0595         (data_len) ? *((u32 *)data_buf) : 0xFFFFFFFF, err);
0596     return;
0597 }
0598 EXPORT_SYMBOL(fc_host_post_fc_event);
0599
0600 /**
0601  * fc_host_post_event - called to post an even on an fc_host.
0602  * @shost:      host the event occurred on
0603  * @event_number:   fc event number obtained from get_fc_event_number()
0604  * @event_code:     fc_host event being posted
0605  * @event_data:     32bits of data for the event being posted
0606  *
0607  * Notes:
0608  *  This routine assumes no locks are held on entry.
0609  */
0610 void
0611 fc_host_post_event(struct Scsi_Host *shost, u32 event_number,
0612         enum fc_host_event_code event_code, u32 event_data)
0613 {
0614     fc_host_post_fc_event(shost, event_number, event_code,
0615         (u32)sizeof(u32), (char *)&event_data, 0);
0616 }
0617 EXPORT_SYMBOL(fc_host_post_event);
0618
0619
0620 /**
0621  * fc_host_post_vendor_event - called to post a vendor unique event
0622  *                      on an fc_host
0623  * @shost:      host the event occurred on
0624  * @event_number:   fc event number obtained from get_fc_event_number()
0625  * @data_len:       amount, in bytes, of vendor unique data
0626  * @data_buf:       pointer to vendor unique data
0627  * @vendor_id:          Vendor id
0628  *
0629  * Notes:
0630  *  This routine assumes no locks are held on entry.
0631  */
0632 void
0633 fc_host_post_vendor_event(struct Scsi_Host *shost, u32 event_number,
0634         u32 data_len, char * data_buf, u64 vendor_id)
0635 {
0636     fc_host_post_fc_event(shost, event_number, FCH_EVT_VENDOR_UNIQUE,
0637         data_len, data_buf, vendor_id);
0638 }
0639 EXPORT_SYMBOL(fc_host_post_vendor_event);
0640
0641 /**
0642  * fc_find_rport_by_wwpn - find the fc_rport pointer for a given wwpn
0643  * @shost:      host the fc_rport is associated with
0644  * @wwpn:       wwpn of the fc_rport device
0645  *
0646  * Notes:
0647  *  This routine assumes no locks are held on entry.
0648  */
0649 struct fc_rport *
0650 fc_find_rport_by_wwpn(struct Scsi_Host *shost, u64 wwpn)
0651 {
0652     struct fc_rport *rport;
0653     unsigned long flags;
0654
0655     spin_lock_irqsave(shost->host_lock, flags);
0656
0657     list_for_each_entry(rport, &fc_host_rports(shost), peers) {
0658         if (rport->port_state != FC_PORTSTATE_ONLINE)
0659             continue;
0660
0661         if (rport->port_name == wwpn) {
0662             spin_unlock_irqrestore(shost->host_lock, flags);
0663             return rport;
0664         }
0665     }
0666
0667     spin_unlock_irqrestore(shost->host_lock, flags);
0668     return NULL;
0669 }
0670 EXPORT_SYMBOL(fc_find_rport_by_wwpn);
0671
0672 static void
0673 fc_li_stats_update(u16 event_type,
0674            struct fc_fpin_stats *stats)
0675 {
0676     stats->li++;
0677     switch (event_type) {
0678     case FPIN_LI_UNKNOWN:
0679         stats->li_failure_unknown++;
0680         break;
0681     case FPIN_LI_LINK_FAILURE:
0682         stats->li_link_failure_count++;
0683         break;
0684     case FPIN_LI_LOSS_OF_SYNC:
0685         stats->li_loss_of_sync_count++;
0686         break;
0687     case FPIN_LI_LOSS_OF_SIG:
0688         stats->li_loss_of_signals_count++;
0689         break;
0690     case FPIN_LI_PRIM_SEQ_ERR:
0691         stats->li_prim_seq_err_count++;
0692         break;
0693     case FPIN_LI_INVALID_TX_WD:
0694         stats->li_invalid_tx_word_count++;
0695         break;
0696     case FPIN_LI_INVALID_CRC:
0697         stats->li_invalid_crc_count++;
0698         break;
0699     case FPIN_LI_DEVICE_SPEC:
0700         stats->li_device_specific++;
0701         break;
0702     }
0703 }
0704
0705 static void
0706 fc_delivery_stats_update(u32 reason_code, struct fc_fpin_stats *stats)
0707 {
0708     stats->dn++;
0709     switch (reason_code) {
0710     case FPIN_DELI_UNKNOWN:
0711         stats->dn_unknown++;
0712         break;
0713     case FPIN_DELI_TIMEOUT:
0714         stats->dn_timeout++;
0715         break;
0716     case FPIN_DELI_UNABLE_TO_ROUTE:
0717         stats->dn_unable_to_route++;
0718         break;
0719     case FPIN_DELI_DEVICE_SPEC:
0720         stats->dn_device_specific++;
0721         break;
0722     }
0723 }
0724
0725 static void
0726 fc_cn_stats_update(u16 event_type, struct fc_fpin_stats *stats)
0727 {
0728     stats->cn++;
0729     switch (event_type) {
0730     case FPIN_CONGN_CLEAR:
0731         stats->cn_clear++;
0732         break;
0733     case FPIN_CONGN_LOST_CREDIT:
0734         stats->cn_lost_credit++;
0735         break;
0736     case FPIN_CONGN_CREDIT_STALL:
0737         stats->cn_credit_stall++;
0738         break;
0739     case FPIN_CONGN_OVERSUBSCRIPTION:
0740         stats->cn_oversubscription++;
0741         break;
0742     case FPIN_CONGN_DEVICE_SPEC:
0743         stats->cn_device_specific++;
0744     }
0745 }
0746
0747 /*
0748  * fc_fpin_li_stats_update - routine to update Link Integrity
0749  * event statistics.
0750  * @shost:      host the FPIN was received on
0751  * @tlv:        pointer to link integrity descriptor
0752  *
0753  */
0754 static void
0755 fc_fpin_li_stats_update(struct Scsi_Host *shost, struct fc_tlv_desc *tlv)
0756 {
0757     u8 i;
0758     struct fc_rport *rport = NULL;
0759     struct fc_rport *attach_rport = NULL;
0760     struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
0761     struct fc_fn_li_desc *li_desc = (struct fc_fn_li_desc *)tlv;
0762     u16 event_type = be16_to_cpu(li_desc->event_type);
0763     u64 wwpn;
0764
0765     rport = fc_find_rport_by_wwpn(shost,
0766                       be64_to_cpu(li_desc->attached_wwpn));
0767     if (rport &&
0768         (rport->roles & FC_PORT_ROLE_FCP_TARGET ||
0769          rport->roles & FC_PORT_ROLE_NVME_TARGET)) {
0770         attach_rport = rport;
0771         fc_li_stats_update(event_type, &attach_rport->fpin_stats);
0772     }
0773
0774     if (be32_to_cpu(li_desc->pname_count) > 0) {
0775         for (i = 0;
0776             i < be32_to_cpu(li_desc->pname_count);
0777             i++) {
0778             wwpn = be64_to_cpu(li_desc->pname_list[i]);
0779             rport = fc_find_rport_by_wwpn(shost, wwpn);
0780             if (rport &&
0781                 (rport->roles & FC_PORT_ROLE_FCP_TARGET ||
0782                 rport->roles & FC_PORT_ROLE_NVME_TARGET)) {
0783                 if (rport == attach_rport)
0784                     continue;
0785                 fc_li_stats_update(event_type,
0786                            &rport->fpin_stats);
0787             }
0788         }
0789     }
0790
0791     if (fc_host->port_name == be64_to_cpu(li_desc->attached_wwpn))
0792         fc_li_stats_update(event_type, &fc_host->fpin_stats);
0793 }
0794
0795 /*
0796  * fc_fpin_delivery_stats_update - routine to update Delivery Notification
0797  * event statistics.
0798  * @shost:      host the FPIN was received on
0799  * @tlv:        pointer to delivery descriptor
0800  *
0801  */
0802 static void
0803 fc_fpin_delivery_stats_update(struct Scsi_Host *shost,
0804                   struct fc_tlv_desc *tlv)
0805 {
0806     struct fc_rport *rport = NULL;
0807     struct fc_rport *attach_rport = NULL;
0808     struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
0809     struct fc_fn_deli_desc *dn_desc = (struct fc_fn_deli_desc *)tlv;
0810     u32 reason_code = be32_to_cpu(dn_desc->deli_reason_code);
0811
0812     rport = fc_find_rport_by_wwpn(shost,
0813                       be64_to_cpu(dn_desc->attached_wwpn));
0814     if (rport &&
0815         (rport->roles & FC_PORT_ROLE_FCP_TARGET ||
0816          rport->roles & FC_PORT_ROLE_NVME_TARGET)) {
0817         attach_rport = rport;
0818         fc_delivery_stats_update(reason_code,
0819                      &attach_rport->fpin_stats);
0820     }
0821
0822     if (fc_host->port_name == be64_to_cpu(dn_desc->attached_wwpn))
0823         fc_delivery_stats_update(reason_code, &fc_host->fpin_stats);
0824 }
0825
0826 /*
0827  * fc_fpin_peer_congn_stats_update - routine to update Peer Congestion
0828  * event statistics.
0829  * @shost:      host the FPIN was received on
0830  * @tlv:        pointer to peer congestion descriptor
0831  *
0832  */
0833 static void
0834 fc_fpin_peer_congn_stats_update(struct Scsi_Host *shost,
0835                 struct fc_tlv_desc *tlv)
0836 {
0837     u8 i;
0838     struct fc_rport *rport = NULL;
0839     struct fc_rport *attach_rport = NULL;
0840     struct fc_fn_peer_congn_desc *pc_desc =
0841         (struct fc_fn_peer_congn_desc *)tlv;
0842     u16 event_type = be16_to_cpu(pc_desc->event_type);
0843     u64 wwpn;
0844
0845     rport = fc_find_rport_by_wwpn(shost,
0846                       be64_to_cpu(pc_desc->attached_wwpn));
0847     if (rport &&
0848         (rport->roles & FC_PORT_ROLE_FCP_TARGET ||
0849          rport->roles & FC_PORT_ROLE_NVME_TARGET)) {
0850         attach_rport = rport;
0851         fc_cn_stats_update(event_type, &attach_rport->fpin_stats);
0852     }
0853
0854     if (be32_to_cpu(pc_desc->pname_count) > 0) {
0855         for (i = 0;
0856             i < be32_to_cpu(pc_desc->pname_count);
0857             i++) {
0858             wwpn = be64_to_cpu(pc_desc->pname_list[i]);
0859             rport = fc_find_rport_by_wwpn(shost, wwpn);
0860             if (rport &&
0861                 (rport->roles & FC_PORT_ROLE_FCP_TARGET ||
0862                  rport->roles & FC_PORT_ROLE_NVME_TARGET)) {
0863                 if (rport == attach_rport)
0864                     continue;
0865                 fc_cn_stats_update(event_type,
0866                            &rport->fpin_stats);
0867             }
0868         }
0869     }
0870 }
0871
0872 /*
0873  * fc_fpin_congn_stats_update - routine to update Congestion
0874  * event statistics.
0875  * @shost:      host the FPIN was received on
0876  * @tlv:        pointer to congestion descriptor
0877  *
0878  */
0879 static void
0880 fc_fpin_congn_stats_update(struct Scsi_Host *shost,
0881                struct fc_tlv_desc *tlv)
0882 {
0883     struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
0884     struct fc_fn_congn_desc *congn = (struct fc_fn_congn_desc *)tlv;
0885
0886     fc_cn_stats_update(be16_to_cpu(congn->event_type),
0887                &fc_host->fpin_stats);
0888 }
0889
0890 /**
0891  * fc_host_fpin_rcv - routine to process a received FPIN.
0892  * @shost:      host the FPIN was received on
0893  * @fpin_len:       length of FPIN payload, in bytes
0894  * @fpin_buf:       pointer to FPIN payload
0895  *
0896  * Notes:
0897  *  This routine assumes no locks are held on entry.
0898  */
0899 void
0900 fc_host_fpin_rcv(struct Scsi_Host *shost, u32 fpin_len, char *fpin_buf)
0901 {
0902     struct fc_els_fpin *fpin = (struct fc_els_fpin *)fpin_buf;
0903     struct fc_tlv_desc *tlv;
0904     u32 desc_cnt = 0, bytes_remain;
0905     u32 dtag;
0906
0907     /* Update Statistics */
0908     tlv = (struct fc_tlv_desc *)&fpin->fpin_desc[0];
0909     bytes_remain = fpin_len - offsetof(struct fc_els_fpin, fpin_desc);
0910     bytes_remain = min_t(u32, bytes_remain, be32_to_cpu(fpin->desc_len));
0911
0912     while (bytes_remain >= FC_TLV_DESC_HDR_SZ &&
0913            bytes_remain >= FC_TLV_DESC_SZ_FROM_LENGTH(tlv)) {
0914         dtag = be32_to_cpu(tlv->desc_tag);
0915         switch (dtag) {
0916         case ELS_DTAG_LNK_INTEGRITY:
0917             fc_fpin_li_stats_update(shost, tlv);
0918             break;
0919         case ELS_DTAG_DELIVERY:
0920             fc_fpin_delivery_stats_update(shost, tlv);
0921             break;
0922         case ELS_DTAG_PEER_CONGEST:
0923             fc_fpin_peer_congn_stats_update(shost, tlv);
0924             break;
0925         case ELS_DTAG_CONGESTION:
0926             fc_fpin_congn_stats_update(shost, tlv);
0927         }
0928
0929         desc_cnt++;
0930         bytes_remain -= FC_TLV_DESC_SZ_FROM_LENGTH(tlv);
0931         tlv = fc_tlv_next_desc(tlv);
0932     }
0933
0934     fc_host_post_fc_event(shost, fc_get_event_number(),
0935                 FCH_EVT_LINK_FPIN, fpin_len, fpin_buf, 0);
0936 }
0937 EXPORT_SYMBOL(fc_host_fpin_rcv);
0938
0939
0940 static __init int fc_transport_init(void)
0941 {
0942     int error;
0943
0944     atomic_set(&fc_event_seq, 0);
0945
0946     error = transport_class_register(&fc_host_class);
0947     if (error)
0948         return error;
0949     error = transport_class_register(&fc_vport_class);
0950     if (error)
0951         goto unreg_host_class;
0952     error = transport_class_register(&fc_rport_class);
0953     if (error)
0954         goto unreg_vport_class;
0955     error = transport_class_register(&fc_transport_class);
0956     if (error)
0957         goto unreg_rport_class;
0958     return 0;
0959
0960 unreg_rport_class:
0961     transport_class_unregister(&fc_rport_class);
0962 unreg_vport_class:
0963     transport_class_unregister(&fc_vport_class);
0964 unreg_host_class:
0965     transport_class_unregister(&fc_host_class);
0966     return error;
0967 }
0968
0969 static void __exit fc_transport_exit(void)
0970 {
0971     transport_class_unregister(&fc_transport_class);
0972     transport_class_unregister(&fc_rport_class);
0973     transport_class_unregister(&fc_host_class);
0974     transport_class_unregister(&fc_vport_class);
0975 }
0976
0977 /*
0978  * FC Remote Port Attribute Management
0979  */
0980
0981 #define fc_rport_show_function(field, format_string, sz, cast)      \
0982 static ssize_t                              \
0983 show_fc_rport_##field (struct device *dev,              \
0984                struct device_attribute *attr, char *buf)    \
0985 {                                   \
0986     struct fc_rport *rport = transport_class_to_rport(dev);     \
0987     struct Scsi_Host *shost = rport_to_shost(rport);        \
0988     struct fc_internal *i = to_fc_internal(shost->transportt);  \
0989     if ((i->f->get_rport_##field) &&                \
0990         !((rport->port_state == FC_PORTSTATE_BLOCKED) ||        \
0991           (rport->port_state == FC_PORTSTATE_DELETED) ||        \
0992           (rport->port_state == FC_PORTSTATE_NOTPRESENT)))      \
0993         i->f->get_rport_##field(rport);             \
0994     return snprintf(buf, sz, format_string, cast rport->field);     \
0995 }
0996
0997 #define fc_rport_store_function(field)                  \
0998 static ssize_t                              \
0999 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);