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