drivers/scsi/scsi_transport_fc.c

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