drivers/scsi/csiostor/csio

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
csio_is_rnode_ready
csio_is_rnode_uninit
csio_is_rnode_wka
csio_rn_lookup
csio_rn_lookup_wwpn
csio_rnode_lookup_portid
csio_rn_dup_flowid
csio_alloc_rnode
csio_free_rnode
csio_get_rnode
csio_put_rnode
csio_confirm_rnode
csio_rn_verify_rparams
__csio_reg_rnode
__csio_unreg_rnode
csio_rns_uninit
csio_rns_ready
csio_rns_offline
csio_rns_disappeared
csio_rnode_devloss_handler
csio_rnode_fwevt_handler
csio_rnode_init
csio_rnode_exit
   1 /*
   2  * This file is part of the Chelsio FCoE driver for Linux.
   3  *
   4  * Copyright (c) 2008-2012 Chelsio Communications, Inc. All rights reserved.
   5  *
   6  * This software is available to you under a choice of one of two
   7  * licenses.  You may choose to be licensed under the terms of the GNU
   8  * General Public License (GPL) Version 2, available from the file
   9  * COPYING in the main directory of this source tree, or the
  10  * OpenIB.org BSD license below:
  11  *
  12  *     Redistribution and use in source and binary forms, with or
  13  *     without modification, are permitted provided that the following
  14  *     conditions are met:
  15  *
  16  *      - Redistributions of source code must retain the above
  17  *        copyright notice, this list of conditions and the following
  18  *        disclaimer.
  19  *
  20  *      - Redistributions in binary form must reproduce the above
  21  *        copyright notice, this list of conditions and the following
  22  *        disclaimer in the documentation and/or other materials
  23  *        provided with the distribution.
  24  *
  25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  32  * SOFTWARE.
  33  */
  34 
  35 #include <linux/string.h>
  36 #include <scsi/scsi_device.h>
  37 #include <scsi/scsi_transport_fc.h>
  38 #include <scsi/fc/fc_els.h>
  39 #include <scsi/fc/fc_fs.h>
  40 
  41 #include "csio_hw.h"
  42 #include "csio_lnode.h"
  43 #include "csio_rnode.h"
  44 
  45 static int csio_rnode_init(struct csio_rnode *, struct csio_lnode *);
  46 static void csio_rnode_exit(struct csio_rnode *);
  47 
  48 /* Static machine forward declarations */
  49 static void csio_rns_uninit(struct csio_rnode *, enum csio_rn_ev);
  50 static void csio_rns_ready(struct csio_rnode *, enum csio_rn_ev);
  51 static void csio_rns_offline(struct csio_rnode *, enum csio_rn_ev);
  52 static void csio_rns_disappeared(struct csio_rnode *, enum csio_rn_ev);
  53 
  54 /* RNF event mapping */
  55 static enum csio_rn_ev fwevt_to_rnevt[] = {
  56         CSIO_RNFE_NONE,         /* None */
  57         CSIO_RNFE_LOGGED_IN,    /* PLOGI_ACC_RCVD  */
  58         CSIO_RNFE_NONE,         /* PLOGI_RJT_RCVD  */
  59         CSIO_RNFE_PLOGI_RECV,   /* PLOGI_RCVD      */
  60         CSIO_RNFE_LOGO_RECV,    /* PLOGO_RCVD      */
  61         CSIO_RNFE_PRLI_DONE,    /* PRLI_ACC_RCVD   */
  62         CSIO_RNFE_NONE,         /* PRLI_RJT_RCVD   */
  63         CSIO_RNFE_PRLI_RECV,    /* PRLI_RCVD       */
  64         CSIO_RNFE_PRLO_RECV,    /* PRLO_RCVD       */
  65         CSIO_RNFE_NONE,         /* NPORT_ID_CHGD   */
  66         CSIO_RNFE_LOGO_RECV,    /* FLOGO_RCVD      */
  67         CSIO_RNFE_NONE,         /* CLR_VIRT_LNK_RCVD */
  68         CSIO_RNFE_LOGGED_IN,    /* FLOGI_ACC_RCVD   */
  69         CSIO_RNFE_NONE,         /* FLOGI_RJT_RCVD   */
  70         CSIO_RNFE_LOGGED_IN,    /* FDISC_ACC_RCVD   */
  71         CSIO_RNFE_NONE,         /* FDISC_RJT_RCVD   */
  72         CSIO_RNFE_NONE,         /* FLOGI_TMO_MAX_RETRY */
  73         CSIO_RNFE_NONE,         /* IMPL_LOGO_ADISC_ACC */
  74         CSIO_RNFE_NONE,         /* IMPL_LOGO_ADISC_RJT */
  75         CSIO_RNFE_NONE,         /* IMPL_LOGO_ADISC_CNFLT */
  76         CSIO_RNFE_NONE,         /* PRLI_TMO             */
  77         CSIO_RNFE_NONE,         /* ADISC_TMO            */
  78         CSIO_RNFE_NAME_MISSING, /* RSCN_DEV_LOST  */
  79         CSIO_RNFE_NONE,         /* SCR_ACC_RCVD */
  80         CSIO_RNFE_NONE,         /* ADISC_RJT_RCVD */
  81         CSIO_RNFE_NONE,         /* LOGO_SNT */
  82         CSIO_RNFE_LOGO_RECV,    /* PROTO_ERR_IMPL_LOGO */
  83 };
  84 
  85 #define CSIO_FWE_TO_RNFE(_evt)  ((_evt > PROTO_ERR_IMPL_LOGO) ?         \
  86                                                 CSIO_RNFE_NONE :        \
  87                                                 fwevt_to_rnevt[_evt])
  88 int
  89 csio_is_rnode_ready(struct csio_rnode *rn)
  90 {
  91         return csio_match_state(rn, csio_rns_ready);
  92 }
  93 
  94 static int
  95 csio_is_rnode_uninit(struct csio_rnode *rn)
  96 {
  97         return csio_match_state(rn, csio_rns_uninit);
  98 }
  99 
 100 static int
 101 csio_is_rnode_wka(uint8_t rport_type)
 102 {
 103         if ((rport_type == FLOGI_VFPORT) ||
 104             (rport_type == FDISC_VFPORT) ||
 105             (rport_type == NS_VNPORT) ||
 106             (rport_type == FDMI_VNPORT))
 107                 return 1;
 108 
 109         return 0;
 110 }
 111 
 112 /*
 113  * csio_rn_lookup - Finds the rnode with the given flowid
 114  * @ln - lnode
 115  * @flowid - flowid.
 116  *
 117  * Does the rnode lookup on the given lnode and flowid.If no matching entry
 118  * found, NULL is returned.
 119  */
 120 static struct csio_rnode *
 121 csio_rn_lookup(struct csio_lnode *ln, uint32_t flowid)
 122 {
 123         struct csio_rnode *rnhead = (struct csio_rnode *) &ln->rnhead;
 124         struct list_head *tmp;
 125         struct csio_rnode *rn;
 126 
 127         list_for_each(tmp, &rnhead->sm.sm_list) {
 128                 rn = (struct csio_rnode *) tmp;
 129                 if (rn->flowid == flowid)
 130                         return rn;
 131         }
 132 
 133         return NULL;
 134 }
 135 
 136 /*
 137  * csio_rn_lookup_wwpn - Finds the rnode with the given wwpn
 138  * @ln: lnode
 139  * @wwpn: wwpn
 140  *
 141  * Does the rnode lookup on the given lnode and wwpn. If no matching entry
 142  * found, NULL is returned.
 143  */
 144 static struct csio_rnode *
 145 csio_rn_lookup_wwpn(struct csio_lnode *ln, uint8_t *wwpn)
 146 {
 147         struct csio_rnode *rnhead = (struct csio_rnode *) &ln->rnhead;
 148         struct list_head *tmp;
 149         struct csio_rnode *rn;
 150 
 151         list_for_each(tmp, &rnhead->sm.sm_list) {
 152                 rn = (struct csio_rnode *) tmp;
 153                 if (!memcmp(csio_rn_wwpn(rn), wwpn, 8))
 154                         return rn;
 155         }
 156 
 157         return NULL;
 158 }
 159 
 160 /**
 161  * csio_rnode_lookup_portid - Finds the rnode with the given portid
 162  * @ln:         lnode
 163  * @portid:     port id
 164  *
 165  * Lookup the rnode list for a given portid. If no matching entry
 166  * found, NULL is returned.
 167  */
 168 struct csio_rnode *
 169 csio_rnode_lookup_portid(struct csio_lnode *ln, uint32_t portid)
 170 {
 171         struct csio_rnode *rnhead = (struct csio_rnode *) &ln->rnhead;
 172         struct list_head *tmp;
 173         struct csio_rnode *rn;
 174 
 175         list_for_each(tmp, &rnhead->sm.sm_list) {
 176                 rn = (struct csio_rnode *) tmp;
 177                 if (rn->nport_id == portid)
 178                         return rn;
 179         }
 180 
 181         return NULL;
 182 }
 183 
 184 static int
 185 csio_rn_dup_flowid(struct csio_lnode *ln, uint32_t rdev_flowid,
 186                     uint32_t *vnp_flowid)
 187 {
 188         struct csio_rnode *rnhead;
 189         struct list_head *tmp, *tmp1;
 190         struct csio_rnode *rn;
 191         struct csio_lnode *ln_tmp;
 192         struct csio_hw *hw = csio_lnode_to_hw(ln);
 193 
 194         list_for_each(tmp1, &hw->sln_head) {
 195                 ln_tmp = (struct csio_lnode *) tmp1;
 196                 if (ln_tmp == ln)
 197                         continue;
 198 
 199                 rnhead = (struct csio_rnode *)&ln_tmp->rnhead;
 200                 list_for_each(tmp, &rnhead->sm.sm_list) {
 201 
 202                         rn = (struct csio_rnode *) tmp;
 203                         if (csio_is_rnode_ready(rn)) {
 204                                 if (rn->flowid == rdev_flowid) {
 205                                         *vnp_flowid = csio_ln_flowid(ln_tmp);
 206                                         return 1;
 207                                 }
 208                         }
 209                 }
 210         }
 211 
 212         return 0;
 213 }
 214 
 215 static struct csio_rnode *
 216 csio_alloc_rnode(struct csio_lnode *ln)
 217 {
 218         struct csio_hw *hw = csio_lnode_to_hw(ln);
 219 
 220         struct csio_rnode *rn = mempool_alloc(hw->rnode_mempool, GFP_ATOMIC);
 221         if (!rn)
 222                 goto err;
 223 
 224         memset(rn, 0, sizeof(struct csio_rnode));
 225         if (csio_rnode_init(rn, ln))
 226                 goto err_free;
 227 
 228         CSIO_INC_STATS(ln, n_rnode_alloc);
 229 
 230         return rn;
 231 
 232 err_free:
 233         mempool_free(rn, hw->rnode_mempool);
 234 err:
 235         CSIO_INC_STATS(ln, n_rnode_nomem);
 236         return NULL;
 237 }
 238 
 239 static void
 240 csio_free_rnode(struct csio_rnode *rn)
 241 {
 242         struct csio_hw *hw = csio_lnode_to_hw(csio_rnode_to_lnode(rn));
 243 
 244         csio_rnode_exit(rn);
 245         CSIO_INC_STATS(rn->lnp, n_rnode_free);
 246         mempool_free(rn, hw->rnode_mempool);
 247 }
 248 
 249 /*
 250  * csio_get_rnode - Gets rnode with the given flowid
 251  * @ln - lnode
 252  * @flowid - flow id.
 253  *
 254  * Does the rnode lookup on the given lnode and flowid. If no matching
 255  * rnode found, then new rnode with given npid is allocated and returned.
 256  */
 257 static struct csio_rnode *
 258 csio_get_rnode(struct csio_lnode *ln, uint32_t flowid)
 259 {
 260         struct csio_rnode *rn;
 261 
 262         rn = csio_rn_lookup(ln, flowid);
 263         if (!rn) {
 264                 rn = csio_alloc_rnode(ln);
 265                 if (!rn)
 266                         return NULL;
 267 
 268                 rn->flowid = flowid;
 269         }
 270 
 271         return rn;
 272 }
 273 
 274 /*
 275  * csio_put_rnode - Frees the given rnode
 276  * @ln - lnode
 277  * @flowid - flow id.
 278  *
 279  * Does the rnode lookup on the given lnode and flowid. If no matching
 280  * rnode found, then new rnode with given npid is allocated and returned.
 281  */
 282 void
 283 csio_put_rnode(struct csio_lnode *ln, struct csio_rnode *rn)
 284 {
 285         CSIO_DB_ASSERT(csio_is_rnode_uninit(rn) != 0);
 286         csio_free_rnode(rn);
 287 }
 288 
 289 /*
 290  * csio_confirm_rnode - confirms rnode based on wwpn.
 291  * @ln: lnode
 292  * @rdev_flowid: remote device flowid
 293  * @rdevp: remote device params
 294  * This routines searches other rnode in list having same wwpn of new rnode.
 295  * If there is a match, then matched rnode is returned and otherwise new rnode
 296  * is returned.
 297  * returns rnode.
 298  */
 299 struct csio_rnode *
 300 csio_confirm_rnode(struct csio_lnode *ln, uint32_t rdev_flowid,
 301                    struct fcoe_rdev_entry *rdevp)
 302 {
 303         uint8_t rport_type;
 304         struct csio_rnode *rn, *match_rn;
 305         uint32_t vnp_flowid = 0;
 306         __be32 *port_id;
 307 
 308         port_id = (__be32 *)&rdevp->r_id[0];
 309         rport_type =
 310                 FW_RDEV_WR_RPORT_TYPE_GET(rdevp->rd_xfer_rdy_to_rport_type);
 311 
 312         /* Drop rdev event for cntrl port */
 313         if (rport_type == FAB_CTLR_VNPORT) {
 314                 csio_ln_dbg(ln,
 315                             "Unhandled rport_type:%d recv in rdev evt "
 316                             "ssni:x%x\n", rport_type, rdev_flowid);
 317                 return NULL;
 318         }
 319 
 320         /* Lookup on flowid */
 321         rn = csio_rn_lookup(ln, rdev_flowid);
 322         if (!rn) {
 323 
 324                 /* Drop events with duplicate flowid */
 325                 if (csio_rn_dup_flowid(ln, rdev_flowid, &vnp_flowid)) {
 326                         csio_ln_warn(ln,
 327                                      "ssni:%x already active on vnpi:%x",
 328                                      rdev_flowid, vnp_flowid);
 329                         return NULL;
 330                 }
 331 
 332                 /* Lookup on wwpn for NPORTs */
 333                 rn = csio_rn_lookup_wwpn(ln, rdevp->wwpn);
 334                 if (!rn)
 335                         goto alloc_rnode;
 336 
 337         } else {
 338                 /* Lookup well-known ports with nport id */
 339                 if (csio_is_rnode_wka(rport_type)) {
 340                         match_rn = csio_rnode_lookup_portid(ln,
 341                                       ((ntohl(*port_id) >> 8) & CSIO_DID_MASK));
 342                         if (match_rn == NULL) {
 343                                 csio_rn_flowid(rn) = CSIO_INVALID_IDX;
 344                                 goto alloc_rnode;
 345                         }
 346 
 347                         /*
 348                          * Now compare the wwpn to confirm that
 349                          * same port relogged in. If so update the matched rn.
 350                          * Else, go ahead and alloc a new rnode.
 351                          */
 352                         if (!memcmp(csio_rn_wwpn(match_rn), rdevp->wwpn, 8)) {
 353                                 if (rn == match_rn)
 354                                         goto found_rnode;
 355                                 csio_ln_dbg(ln,
 356                                             "nport_id:x%x and wwpn:%llx"
 357                                             " match for ssni:x%x\n",
 358                                             rn->nport_id,
 359                                             wwn_to_u64(rdevp->wwpn),
 360                                             rdev_flowid);
 361                                 if (csio_is_rnode_ready(rn)) {
 362                                         csio_ln_warn(ln,
 363                                                      "rnode is already"
 364                                                      "active ssni:x%x\n",
 365                                                      rdev_flowid);
 366                                         CSIO_ASSERT(0);
 367                                 }
 368                                 csio_rn_flowid(rn) = CSIO_INVALID_IDX;
 369                                 rn = match_rn;
 370 
 371                                 /* Update rn */
 372                                 goto found_rnode;
 373                         }
 374                         csio_rn_flowid(rn) = CSIO_INVALID_IDX;
 375                         goto alloc_rnode;
 376                 }
 377 
 378                 /* wwpn match */
 379                 if (!memcmp(csio_rn_wwpn(rn), rdevp->wwpn, 8))
 380                         goto found_rnode;
 381 
 382                 /* Search for rnode that have same wwpn */
 383                 match_rn = csio_rn_lookup_wwpn(ln, rdevp->wwpn);
 384                 if (match_rn != NULL) {
 385                         csio_ln_dbg(ln,
 386                                 "ssni:x%x changed for rport name(wwpn):%llx "
 387                                 "did:x%x\n", rdev_flowid,
 388                                 wwn_to_u64(rdevp->wwpn),
 389                                 match_rn->nport_id);
 390                         csio_rn_flowid(rn) = CSIO_INVALID_IDX;
 391                         rn = match_rn;
 392                 } else {
 393                         csio_ln_dbg(ln,
 394                                 "rnode wwpn mismatch found ssni:x%x "
 395                                 "name(wwpn):%llx\n",
 396                                 rdev_flowid,
 397                                 wwn_to_u64(csio_rn_wwpn(rn)));
 398                         if (csio_is_rnode_ready(rn)) {
 399                                 csio_ln_warn(ln,
 400                                              "rnode is already active "
 401                                              "wwpn:%llx ssni:x%x\n",
 402                                              wwn_to_u64(csio_rn_wwpn(rn)),
 403                                              rdev_flowid);
 404                                 CSIO_ASSERT(0);
 405                         }
 406                         csio_rn_flowid(rn) = CSIO_INVALID_IDX;
 407                         goto alloc_rnode;
 408                 }
 409         }
 410 
 411 found_rnode:
 412         csio_ln_dbg(ln, "found rnode:%p ssni:x%x name(wwpn):%llx\n",
 413                 rn, rdev_flowid, wwn_to_u64(rdevp->wwpn));
 414 
 415         /* Update flowid */
 416         csio_rn_flowid(rn) = rdev_flowid;
 417 
 418         /* update rdev entry */
 419         rn->rdev_entry = rdevp;
 420         CSIO_INC_STATS(ln, n_rnode_match);
 421         return rn;
 422 
 423 alloc_rnode:
 424         rn = csio_get_rnode(ln, rdev_flowid);
 425         if (!rn)
 426                 return NULL;
 427 
 428         csio_ln_dbg(ln, "alloc rnode:%p ssni:x%x name(wwpn):%llx\n",
 429                 rn, rdev_flowid, wwn_to_u64(rdevp->wwpn));
 430 
 431         /* update rdev entry */
 432         rn->rdev_entry = rdevp;
 433         return rn;
 434 }
 435 
 436 /*
 437  * csio_rn_verify_rparams - verify rparams.
 438  * @ln: lnode
 439  * @rn: rnode
 440  * @rdevp: remote device params
 441  * returns success if rparams are verified.
 442  */
 443 static int
 444 csio_rn_verify_rparams(struct csio_lnode *ln, struct csio_rnode *rn,
 445                         struct fcoe_rdev_entry *rdevp)
 446 {
 447         uint8_t null[8];
 448         uint8_t rport_type;
 449         uint8_t fc_class;
 450         __be32 *did;
 451 
 452         did = (__be32 *) &rdevp->r_id[0];
 453         rport_type =
 454                 FW_RDEV_WR_RPORT_TYPE_GET(rdevp->rd_xfer_rdy_to_rport_type);
 455         switch (rport_type) {
 456         case FLOGI_VFPORT:
 457                 rn->role = CSIO_RNFR_FABRIC;
 458                 if (((ntohl(*did) >> 8) & CSIO_DID_MASK) != FC_FID_FLOGI) {
 459                         csio_ln_err(ln, "ssni:x%x invalid fabric portid\n",
 460                                 csio_rn_flowid(rn));
 461                         return -EINVAL;
 462                 }
 463                 /* NPIV support */
 464                 if (FW_RDEV_WR_NPIV_GET(rdevp->vft_to_qos))
 465                         ln->flags |= CSIO_LNF_NPIVSUPP;
 466 
 467                 break;
 468 
 469         case NS_VNPORT:
 470                 rn->role = CSIO_RNFR_NS;
 471                 if (((ntohl(*did) >> 8) & CSIO_DID_MASK) != FC_FID_DIR_SERV) {
 472                         csio_ln_err(ln, "ssni:x%x invalid fabric portid\n",
 473                                 csio_rn_flowid(rn));
 474                         return -EINVAL;
 475                 }
 476                 break;
 477 
 478         case REG_FC4_VNPORT:
 479         case REG_VNPORT:
 480                 rn->role = CSIO_RNFR_NPORT;
 481                 if (rdevp->event_cause == PRLI_ACC_RCVD ||
 482                         rdevp->event_cause == PRLI_RCVD) {
 483                         if (FW_RDEV_WR_TASK_RETRY_ID_GET(
 484                                                         rdevp->enh_disc_to_tgt))
 485                                 rn->fcp_flags |= FCP_SPPF_OVLY_ALLOW;
 486 
 487                         if (FW_RDEV_WR_RETRY_GET(rdevp->enh_disc_to_tgt))
 488                                 rn->fcp_flags |= FCP_SPPF_RETRY;
 489 
 490                         if (FW_RDEV_WR_CONF_CMPL_GET(rdevp->enh_disc_to_tgt))
 491                                 rn->fcp_flags |= FCP_SPPF_CONF_COMPL;
 492 
 493                         if (FW_RDEV_WR_TGT_GET(rdevp->enh_disc_to_tgt))
 494                                 rn->role |= CSIO_RNFR_TARGET;
 495 
 496                         if (FW_RDEV_WR_INI_GET(rdevp->enh_disc_to_tgt))
 497                                 rn->role |= CSIO_RNFR_INITIATOR;
 498                 }
 499 
 500                 break;
 501 
 502         case FDMI_VNPORT:
 503         case FAB_CTLR_VNPORT:
 504                 rn->role = 0;
 505                 break;
 506 
 507         default:
 508                 csio_ln_err(ln, "ssni:x%x invalid rport type recv x%x\n",
 509                         csio_rn_flowid(rn), rport_type);
 510                 return -EINVAL;
 511         }
 512 
 513         /* validate wwpn/wwnn for Name server/remote port */
 514         if (rport_type == REG_VNPORT || rport_type == NS_VNPORT) {
 515                 memset(null, 0, 8);
 516                 if (!memcmp(rdevp->wwnn, null, 8)) {
 517                         csio_ln_err(ln,
 518                                     "ssni:x%x invalid wwnn received from"
 519                                     " rport did:x%x\n",
 520                                     csio_rn_flowid(rn),
 521                                     (ntohl(*did) & CSIO_DID_MASK));
 522                         return -EINVAL;
 523                 }
 524 
 525                 if (!memcmp(rdevp->wwpn, null, 8)) {
 526                         csio_ln_err(ln,
 527                                     "ssni:x%x invalid wwpn received from"
 528                                     " rport did:x%x\n",
 529                                     csio_rn_flowid(rn),
 530                                     (ntohl(*did) & CSIO_DID_MASK));
 531                         return -EINVAL;
 532                 }
 533 
 534         }
 535 
 536         /* Copy wwnn, wwpn and nport id */
 537         rn->nport_id = (ntohl(*did) >> 8) & CSIO_DID_MASK;
 538         memcpy(csio_rn_wwnn(rn), rdevp->wwnn, 8);
 539         memcpy(csio_rn_wwpn(rn), rdevp->wwpn, 8);
 540         rn->rn_sparm.csp.sp_bb_data = rdevp->rcv_fr_sz;
 541         fc_class = FW_RDEV_WR_CLASS_GET(rdevp->vft_to_qos);
 542         rn->rn_sparm.clsp[fc_class - 1].cp_class = htons(FC_CPC_VALID);
 543 
 544         return 0;
 545 }
 546 
 547 static void
 548 __csio_reg_rnode(struct csio_rnode *rn)
 549 {
 550         struct csio_lnode *ln = csio_rnode_to_lnode(rn);
 551         struct csio_hw *hw = csio_lnode_to_hw(ln);
 552 
 553         spin_unlock_irq(&hw->lock);
 554         csio_reg_rnode(rn);
 555         spin_lock_irq(&hw->lock);
 556 
 557         if (rn->role & CSIO_RNFR_TARGET)
 558                 ln->n_scsi_tgts++;
 559 
 560         if (rn->nport_id == FC_FID_MGMT_SERV)
 561                 csio_ln_fdmi_start(ln, (void *) rn);
 562 }
 563 
 564 static void
 565 __csio_unreg_rnode(struct csio_rnode *rn)
 566 {
 567         struct csio_lnode *ln = csio_rnode_to_lnode(rn);
 568         struct csio_hw *hw = csio_lnode_to_hw(ln);
 569         LIST_HEAD(tmp_q);
 570         int cmpl = 0;
 571 
 572         if (!list_empty(&rn->host_cmpl_q)) {
 573                 csio_dbg(hw, "Returning completion queue I/Os\n");
 574                 list_splice_tail_init(&rn->host_cmpl_q, &tmp_q);
 575                 cmpl = 1;
 576         }
 577 
 578         if (rn->role & CSIO_RNFR_TARGET) {
 579                 ln->n_scsi_tgts--;
 580                 ln->last_scan_ntgts--;
 581         }
 582 
 583         spin_unlock_irq(&hw->lock);
 584         csio_unreg_rnode(rn);
 585         spin_lock_irq(&hw->lock);
 586 
 587         /* Cleanup I/Os that were waiting for rnode to unregister */
 588         if (cmpl)
 589                 csio_scsi_cleanup_io_q(csio_hw_to_scsim(hw), &tmp_q);
 590 
 591 }
 592 
 593 /*****************************************************************************/
 594 /* START: Rnode SM                                                           */
 595 /*****************************************************************************/
 596 
 597 /*
 598  * csio_rns_uninit -
 599  * @rn - rnode
 600  * @evt - SM event.
 601  *
 602  */
 603 static void
 604 csio_rns_uninit(struct csio_rnode *rn, enum csio_rn_ev evt)
 605 {
 606         struct csio_lnode *ln = csio_rnode_to_lnode(rn);
 607         int ret = 0;
 608 
 609         CSIO_INC_STATS(rn, n_evt_sm[evt]);
 610 
 611         switch (evt) {
 612         case CSIO_RNFE_LOGGED_IN:
 613         case CSIO_RNFE_PLOGI_RECV:
 614                 ret = csio_rn_verify_rparams(ln, rn, rn->rdev_entry);
 615                 if (!ret) {
 616                         csio_set_state(&rn->sm, csio_rns_ready);
 617                         __csio_reg_rnode(rn);
 618                 } else {
 619                         CSIO_INC_STATS(rn, n_err_inval);
 620                 }
 621                 break;
 622         case CSIO_RNFE_LOGO_RECV:
 623                 csio_ln_dbg(ln,
 624                             "ssni:x%x Ignoring event %d recv "
 625                             "in rn state[uninit]\n", csio_rn_flowid(rn), evt);
 626                 CSIO_INC_STATS(rn, n_evt_drop);
 627                 break;
 628         default:
 629                 csio_ln_dbg(ln,
 630                             "ssni:x%x unexp event %d recv "
 631                             "in rn state[uninit]\n", csio_rn_flowid(rn), evt);
 632                 CSIO_INC_STATS(rn, n_evt_unexp);
 633                 break;
 634         }
 635 }
 636 
 637 /*
 638  * csio_rns_ready -
 639  * @rn - rnode
 640  * @evt - SM event.
 641  *
 642  */
 643 static void
 644 csio_rns_ready(struct csio_rnode *rn, enum csio_rn_ev evt)
 645 {
 646         struct csio_lnode *ln = csio_rnode_to_lnode(rn);
 647         int ret = 0;
 648 
 649         CSIO_INC_STATS(rn, n_evt_sm[evt]);
 650 
 651         switch (evt) {
 652         case CSIO_RNFE_LOGGED_IN:
 653         case CSIO_RNFE_PLOGI_RECV:
 654                 csio_ln_dbg(ln,
 655                         "ssni:x%x Ignoring event %d recv from did:x%x "
 656                         "in rn state[ready]\n", csio_rn_flowid(rn), evt,
 657                         rn->nport_id);
 658                 CSIO_INC_STATS(rn, n_evt_drop);
 659                 break;
 660 
 661         case CSIO_RNFE_PRLI_DONE:
 662         case CSIO_RNFE_PRLI_RECV:
 663                 ret = csio_rn_verify_rparams(ln, rn, rn->rdev_entry);
 664                 if (!ret)
 665                         __csio_reg_rnode(rn);
 666                 else
 667                         CSIO_INC_STATS(rn, n_err_inval);
 668 
 669                 break;
 670         case CSIO_RNFE_DOWN:
 671                 csio_set_state(&rn->sm, csio_rns_offline);
 672                 __csio_unreg_rnode(rn);
 673 
 674                 /* FW expected to internally aborted outstanding SCSI WRs
 675                  * and return all SCSI WRs to host with status "ABORTED".
 676                  */
 677                 break;
 678 
 679         case CSIO_RNFE_LOGO_RECV:
 680                 csio_set_state(&rn->sm, csio_rns_offline);
 681 
 682                 __csio_unreg_rnode(rn);
 683 
 684                 /* FW expected to internally aborted outstanding SCSI WRs
 685                  * and return all SCSI WRs to host with status "ABORTED".
 686                  */
 687                 break;
 688 
 689         case CSIO_RNFE_CLOSE:
 690                 /*
 691                  * Each rnode receives CLOSE event when driver is removed or
 692                  * device is reset
 693                  * Note: All outstanding IOs on remote port need to returned
 694                  * to uppper layer with appropriate error before sending
 695                  * CLOSE event
 696                  */
 697                 csio_set_state(&rn->sm, csio_rns_uninit);
 698                 __csio_unreg_rnode(rn);
 699                 break;
 700 
 701         case CSIO_RNFE_NAME_MISSING:
 702                 csio_set_state(&rn->sm, csio_rns_disappeared);
 703                 __csio_unreg_rnode(rn);
 704 
 705                 /*
 706                  * FW expected to internally aborted outstanding SCSI WRs
 707                  * and return all SCSI WRs to host with status "ABORTED".
 708                  */
 709 
 710                 break;
 711 
 712         default:
 713                 csio_ln_dbg(ln,
 714                         "ssni:x%x unexp event %d recv from did:x%x "
 715                         "in rn state[uninit]\n", csio_rn_flowid(rn), evt,
 716                         rn->nport_id);
 717                 CSIO_INC_STATS(rn, n_evt_unexp);
 718                 break;
 719         }
 720 }
 721 
 722 /*
 723  * csio_rns_offline -
 724  * @rn - rnode
 725  * @evt - SM event.
 726  *
 727  */
 728 static void
 729 csio_rns_offline(struct csio_rnode *rn, enum csio_rn_ev evt)
 730 {
 731         struct csio_lnode *ln = csio_rnode_to_lnode(rn);
 732         int ret = 0;
 733 
 734         CSIO_INC_STATS(rn, n_evt_sm[evt]);
 735 
 736         switch (evt) {
 737         case CSIO_RNFE_LOGGED_IN:
 738         case CSIO_RNFE_PLOGI_RECV:
 739                 ret = csio_rn_verify_rparams(ln, rn, rn->rdev_entry);
 740                 if (!ret) {
 741                         csio_set_state(&rn->sm, csio_rns_ready);
 742                         __csio_reg_rnode(rn);
 743                 } else {
 744                         CSIO_INC_STATS(rn, n_err_inval);
 745                         csio_post_event(&rn->sm, CSIO_RNFE_CLOSE);
 746                 }
 747                 break;
 748 
 749         case CSIO_RNFE_DOWN:
 750                 csio_ln_dbg(ln,
 751                         "ssni:x%x Ignoring event %d recv from did:x%x "
 752                         "in rn state[offline]\n", csio_rn_flowid(rn), evt,
 753                         rn->nport_id);
 754                 CSIO_INC_STATS(rn, n_evt_drop);
 755                 break;
 756 
 757         case CSIO_RNFE_CLOSE:
 758                 /* Each rnode receives CLOSE event when driver is removed or
 759                  * device is reset
 760                  * Note: All outstanding IOs on remote port need to returned
 761                  * to uppper layer with appropriate error before sending
 762                  * CLOSE event
 763                  */
 764                 csio_set_state(&rn->sm, csio_rns_uninit);
 765                 break;
 766 
 767         case CSIO_RNFE_NAME_MISSING:
 768                 csio_set_state(&rn->sm, csio_rns_disappeared);
 769                 break;
 770 
 771         default:
 772                 csio_ln_dbg(ln,
 773                         "ssni:x%x unexp event %d recv from did:x%x "
 774                         "in rn state[offline]\n", csio_rn_flowid(rn), evt,
 775                         rn->nport_id);
 776                 CSIO_INC_STATS(rn, n_evt_unexp);
 777                 break;
 778         }
 779 }
 780 
 781 /*
 782  * csio_rns_disappeared -
 783  * @rn - rnode
 784  * @evt - SM event.
 785  *
 786  */
 787 static void
 788 csio_rns_disappeared(struct csio_rnode *rn, enum csio_rn_ev evt)
 789 {
 790         struct csio_lnode *ln = csio_rnode_to_lnode(rn);
 791         int ret = 0;
 792 
 793         CSIO_INC_STATS(rn, n_evt_sm[evt]);
 794 
 795         switch (evt) {
 796         case CSIO_RNFE_LOGGED_IN:
 797         case CSIO_RNFE_PLOGI_RECV:
 798                 ret = csio_rn_verify_rparams(ln, rn, rn->rdev_entry);
 799                 if (!ret) {
 800                         csio_set_state(&rn->sm, csio_rns_ready);
 801                         __csio_reg_rnode(rn);
 802                 } else {
 803                         CSIO_INC_STATS(rn, n_err_inval);
 804                         csio_post_event(&rn->sm, CSIO_RNFE_CLOSE);
 805                 }
 806                 break;
 807 
 808         case CSIO_RNFE_CLOSE:
 809                 /* Each rnode receives CLOSE event when driver is removed or
 810                  * device is reset.
 811                  * Note: All outstanding IOs on remote port need to returned
 812                  * to uppper layer with appropriate error before sending
 813                  * CLOSE event
 814                  */
 815                 csio_set_state(&rn->sm, csio_rns_uninit);
 816                 break;
 817 
 818         case CSIO_RNFE_DOWN:
 819         case CSIO_RNFE_NAME_MISSING:
 820                 csio_ln_dbg(ln,
 821                         "ssni:x%x Ignoring event %d recv from did x%x"
 822                         "in rn state[disappeared]\n", csio_rn_flowid(rn),
 823                         evt, rn->nport_id);
 824                 break;
 825 
 826         default:
 827                 csio_ln_dbg(ln,
 828                         "ssni:x%x unexp event %d recv from did x%x"
 829                         "in rn state[disappeared]\n", csio_rn_flowid(rn),
 830                         evt, rn->nport_id);
 831                 CSIO_INC_STATS(rn, n_evt_unexp);
 832                 break;
 833         }
 834 }
 835 
 836 /*****************************************************************************/
 837 /* END: Rnode SM                                                             */
 838 /*****************************************************************************/
 839 
 840 /*
 841  * csio_rnode_devloss_handler - Device loss event handler
 842  * @rn: rnode
 843  *
 844  * Post event to close rnode SM and free rnode.
 845  */
 846 void
 847 csio_rnode_devloss_handler(struct csio_rnode *rn)
 848 {
 849         struct csio_lnode *ln = csio_rnode_to_lnode(rn);
 850 
 851         /* ignore if same rnode came back as online */
 852         if (csio_is_rnode_ready(rn))
 853                 return;
 854 
 855         csio_post_event(&rn->sm, CSIO_RNFE_CLOSE);
 856 
 857         /* Free rn if in uninit state */
 858         if (csio_is_rnode_uninit(rn))
 859                 csio_put_rnode(ln, rn);
 860 }
 861 
 862 /**
 863  * csio_rnode_fwevt_handler - Event handler for firmware rnode events.
 864  * @rn:         rnode
 865  *
 866  */
 867 void
 868 csio_rnode_fwevt_handler(struct csio_rnode *rn, uint8_t fwevt)
 869 {
 870         struct csio_lnode *ln = csio_rnode_to_lnode(rn);
 871         enum csio_rn_ev evt;
 872 
 873         evt = CSIO_FWE_TO_RNFE(fwevt);
 874         if (!evt) {
 875                 csio_ln_err(ln, "ssni:x%x Unhandled FW Rdev event: %d\n",
 876                             csio_rn_flowid(rn), fwevt);
 877                 CSIO_INC_STATS(rn, n_evt_unexp);
 878                 return;
 879         }
 880         CSIO_INC_STATS(rn, n_evt_fw[fwevt]);
 881 
 882         /* Track previous & current events for debugging */
 883         rn->prev_evt = rn->cur_evt;
 884         rn->cur_evt = fwevt;
 885 
 886         /* Post event to rnode SM */
 887         csio_post_event(&rn->sm, evt);
 888 
 889         /* Free rn if in uninit state */
 890         if (csio_is_rnode_uninit(rn))
 891                 csio_put_rnode(ln, rn);
 892 }
 893 
 894 /*
 895  * csio_rnode_init - Initialize rnode.
 896  * @rn: RNode
 897  * @ln: Associated lnode
 898  *
 899  * Caller is responsible for holding the lock. The lock is required
 900  * to be held for inserting the rnode in ln->rnhead list.
 901  */
 902 static int
 903 csio_rnode_init(struct csio_rnode *rn, struct csio_lnode *ln)
 904 {
 905         csio_rnode_to_lnode(rn) = ln;
 906         csio_init_state(&rn->sm, csio_rns_uninit);
 907         INIT_LIST_HEAD(&rn->host_cmpl_q);
 908         csio_rn_flowid(rn) = CSIO_INVALID_IDX;
 909 
 910         /* Add rnode to list of lnodes->rnhead */
 911         list_add_tail(&rn->sm.sm_list, &ln->rnhead);
 912 
 913         return 0;
 914 }
 915 
 916 static void
 917 csio_rnode_exit(struct csio_rnode *rn)
 918 {
 919         list_del_init(&rn->sm.sm_list);
 920         CSIO_DB_ASSERT(list_empty(&rn->host_cmpl_q));
 921 }
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/scsi/csiostor/csio_rnode.c

DEFINITIONS
