sys/dev/iscsi_initiator/isc_sm.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2005-2010 Daniel Braniss <danny@cs.huji.ac.il>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  */
  29 /*
  30  | iSCSI - Session Manager
  31  | $Id: isc_sm.c 743 2009-08-08 10:54:53Z danny $
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 #include "opt_iscsi_initiator.h"
  38
  39 #include <sys/param.h>
  40 #include <sys/kernel.h>
  41 #include <sys/conf.h>
  42 #include <sys/systm.h>
  43 #include <sys/malloc.h>
  44 #include <sys/ctype.h>
  45 #include <sys/errno.h>
  46 #include <sys/sysctl.h>
  47 #include <sys/file.h>
  48 #include <sys/uio.h>
  49 #include <sys/socketvar.h>
  50 #include <sys/socket.h>
  51 #include <sys/protosw.h>
  52 #include <sys/proc.h>
  53 #include <sys/ioccom.h>
  54 #include <sys/queue.h>
  55 #include <sys/kthread.h>
  56 #include <sys/syslog.h>
  57 #include <sys/mbuf.h>
  58 #include <sys/bus.h>
  59 #include <sys/sbuf.h>
  60 #include <sys/sx.h>
  61 #include <vm/uma.h>
  62
  63 #include <cam/cam.h>
  64 #include <cam/cam_ccb.h>
  65 #include <cam/cam_sim.h>
  66 #include <cam/cam_xpt_sim.h>
  67 #include <cam/cam_periph.h>
  68
  69 #include <dev/iscsi_initiator/iscsi.h>
  70 #include <dev/iscsi_initiator/iscsivar.h>
  71
  72 static void
  73 _async(isc_session_t *sp, pduq_t *pq)
  74 {
  75      debug_called(8);
  76
  77      iscsi_async(sp, pq);
  78
  79      pdu_free(sp->isc, pq);
  80 }
  81
  82 static void
  83 _reject(isc_session_t *sp, pduq_t *pq)
  84 {
  85      pduq_t     *opq;
  86      pdu_t      *pdu;
  87      reject_t   *reject;
  88      int        itt;
  89
  90      debug_called(8);
  91      pdu = mtod(pq->mp, pdu_t *);
  92      itt = pdu->ipdu.bhs.itt;
  93      reject = &pq->pdu.ipdu.reject;
  94      sdebug(2, "itt=%x reason=0x%x", ntohl(itt), reject->reason);
  95      opq = i_search_hld(sp, itt, 0);
  96      if(opq != NULL)
  97           iscsi_reject(sp, opq, pq);
  98      else {
  99           switch(pq->pdu.ipdu.bhs.opcode) {
 100           case ISCSI_LOGOUT_CMD: // XXX: wasabi does this - can't figure out why
 101                sdebug(2, "ISCSI_LOGOUT_CMD ...");
 102                break;
 103           default:
 104                xdebug("%d] we lost something itt=%x",
 105                       sp->sid, ntohl(pq->pdu.ipdu.bhs.itt));
 106           }
 107      }
 108      pdu_free(sp->isc, pq);
 109 }
 110
 111 static void
 112 _r2t(isc_session_t *sp, pduq_t *pq)
 113 {
 114      pduq_t     *opq;
 115
 116      debug_called(8);
 117      opq = i_search_hld(sp, pq->pdu.ipdu.bhs.itt, 1);
 118      if(opq != NULL) {
 119           iscsi_r2t(sp, opq, pq);
 120      }
 121      else {
 122           r2t_t         *r2t = &pq->pdu.ipdu.r2t;
 123
 124           xdebug("%d] we lost something itt=%x r2tSN=%d bo=%x ddtl=%x",
 125                  sp->sid, ntohl(pq->pdu.ipdu.bhs.itt),
 126                  ntohl(r2t->r2tSN), ntohl(r2t->bo), ntohl(r2t->ddtl));
 127      }
 128      pdu_free(sp->isc, pq);
 129 }
 130
 131 static void
 132 _scsi_rsp(isc_session_t *sp, pduq_t *pq)
 133 {
 134      pduq_t     *opq;
 135
 136      debug_called(8);
 137      opq = i_search_hld(sp, pq->pdu.ipdu.bhs.itt, 0);
 138      debug(5, "itt=%x pq=%p opq=%p", ntohl(pq->pdu.ipdu.bhs.itt), pq, opq);
 139      if(opq != NULL) {
 140           iscsi_done(sp, opq, pq);
 141           i_acked_hld(sp, &pq->pdu);
 142      }
 143      else
 144           xdebug("%d] we lost something itt=%x",
 145                  sp->sid, ntohl(pq->pdu.ipdu.bhs.itt));
 146      pdu_free(sp->isc, pq);
 147 }
 148
 149 static void
 150 _read_data(isc_session_t *sp, pduq_t *pq)
 151 {
 152      pduq_t             *opq;
 153
 154      debug_called(8);
 155      opq = i_search_hld(sp, pq->pdu.ipdu.bhs.itt, 1);
 156      if(opq != NULL) {
 157           if(scsi_decap(sp, opq, pq) != 1) {
 158                i_remove_hld(sp, opq); // done
 159                pdu_free(sp->isc, opq);
 160           }
 161      }
 162      else
 163           xdebug("%d] we lost something itt=%x",
 164                  sp->sid, ntohl(pq->pdu.ipdu.bhs.itt));
 165      pdu_free(sp->isc, pq);
 166 }
 167 /*
 168  | this is a kludge,
 169  | the jury is not back with a veredict, user or kernel
 170  */
 171 static void
 172 _nop_out(isc_session_t *sp)
 173 {
 174      pduq_t     *pq;
 175      nop_out_t  *nop_out;
 176
 177      debug_called(8);
 178
 179      sdebug(4, "cws=%d", sp->cws);
 180      if(sp->cws == 0) {
 181           /*
 182            | only send a nop if window is closed.
 183            */
 184           if((pq = pdu_alloc(sp->isc, M_NOWAIT)) == NULL)
 185                // I guess we ran out of resources
 186                return;
 187           nop_out = &pq->pdu.ipdu.nop_out;
 188           nop_out->opcode = ISCSI_NOP_OUT;
 189           nop_out->itt = htonl(sp->sn.itt);
 190           nop_out->ttt = -1;
 191           nop_out->I = 1;
 192           nop_out->F = 1;
 193           if(isc_qout(sp, pq) != 0) {
 194                sdebug(1, "failed");
 195                pdu_free(sp->isc, pq);
 196           }
 197      }
 198 }
 199
 200 static void
 201 _nop_in(isc_session_t *sp, pduq_t *pq)
 202 {
 203      pdu_t      *pp = &pq->pdu;
 204      nop_in_t   *nop_in = &pp->ipdu.nop_in;
 205      bhs_t      *bhs = &pp->ipdu.bhs;
 206
 207      debug_called(8);
 208
 209      sdebug(5, "itt=%x ttt=%x", htonl(nop_in->itt), htonl(nop_in->ttt));
 210      if(nop_in->itt == -1) {
 211           if(pp->ds_len != 0) {
 212                /*
 213                 | according to RFC 3720 this should be zero
 214                 | what to do if not?
 215                 */
 216                xdebug("%d] dslen not zero", sp->sid);
 217           }
 218           if(nop_in->ttt != -1) {
 219                nop_out_t        *nop_out;
 220                /*
 221                 | target wants a nop_out
 222                 */
 223                bhs->opcode = ISCSI_NOP_OUT;
 224                bhs->I = 1;
 225                bhs->F = 1;
 226                /*
 227                 | we are reusing the pdu, so bhs->ttt == nop_in->ttt;
 228                 | and need to zero out 'Reserved'
 229                 | small cludge here.
 230                 */
 231                nop_out = &pp->ipdu.nop_out;
 232                nop_out->sn.maxcmd = 0;
 233                memset(nop_out->mbz, 0, sizeof(nop_out->mbz));
 234                (void)isc_qout(sp, pq); //XXX: should check return?
 235                return;
 236           }
 237           //else {
 238                // just making noise?
 239                // see 10.9.1: target does not want and answer.
 240           //}
 241
 242      } else
 243      if(nop_in->ttt == -1) {
 244           /*
 245            | it is an answer to a nop_in from us
 246            */
 247           if(nop_in->itt != -1) {
 248 #ifdef ISC_WAIT4PING
 249                // XXX: MUTEX please
 250                if(sp->flags & ISC_WAIT4PING) {
 251                     i_nqueue_rsp(sp, pq);
 252                     wakeup(&sp->rsp);
 253                     return;
 254                }
 255 #endif
 256           }
 257      }
 258      /*
 259       | drop it
 260       */
 261      pdu_free(sp->isc, pq);
 262      return;
 263 }
 264
 265 int
 266 i_prepPDU(isc_session_t *sp, pduq_t *pq)
 267 {
 268      size_t     len, n;
 269      pdu_t      *pp = &pq->pdu;
 270      bhs_t      *bhp = &pp->ipdu.bhs;
 271
 272      len = sizeof(bhs_t);
 273      if(pp->ahs_len) {
 274           len += pp->ahs_len;
 275           bhp->AHSLength =  pp->ahs_len / 4;
 276      }
 277      if(ISOK2DIG(sp->hdrDigest, pp))
 278           len += 4;
 279      if(pp->ds_len) {
 280           n = pp->ds_len;
 281           len += n;
 282 #if BYTE_ORDER == LITTLE_ENDIAN
 283           bhp->DSLength = ((n & 0x00ff0000) >> 16)
 284                | (n & 0x0000ff00)
 285                | ((n & 0x000000ff) << 16);
 286 #else
 287           bhp->DSLength = n;
 288 #endif
 289           if(len & 03) {
 290                n = 4 - (len & 03);
 291                len += n;
 292           }
 293           if(ISOK2DIG(sp->dataDigest, pp))
 294                len += 4;
 295      }
 296
 297      pq->len = len;
 298      len -= sizeof(bhs_t);
 299      if(sp->opt.maxBurstLength && (len > sp->opt.maxBurstLength)) {
 300           xdebug("%d] pdu len=%zd > %d",
 301                  sp->sid, len, sp->opt.maxBurstLength);
 302           // XXX: when this happens it used to hang ...
 303           return E2BIG;
 304      }
 305      return 0;
 306 }
 307
 308 int
 309 isc_qout(isc_session_t *sp, pduq_t *pq)
 310 {
 311      int error = 0;
 312
 313      debug_called(8);
 314
 315      if(pq->len == 0 && (error = i_prepPDU(sp, pq)))
 316           return error;
 317
 318      if(pq->pdu.ipdu.bhs.I)
 319           i_nqueue_isnd(sp, pq);
 320      else
 321      if(pq->pdu.ipdu.data_out.opcode == ISCSI_WRITE_DATA)
 322           i_nqueue_wsnd(sp, pq);
 323      else
 324           i_nqueue_csnd(sp, pq);
 325
 326      sdebug(5, "enqued: pq=%p", pq);
 327
 328      mtx_lock(&sp->io_mtx);
 329      sp->flags |= ISC_OQNOTEMPTY;
 330      if(sp->flags & ISC_OWAITING)
 331           wakeup(&sp->flags);
 332      mtx_unlock(&sp->io_mtx);
 333
 334      return error;
 335 }
 336 /*
 337  | called when a fullPhase is restarted
 338  */
 339 void
 340 ism_restart(isc_session_t *sp)
 341 {
 342      int lastcmd;
 343
 344      sdebug(2, "restart ...");
 345      lastcmd = iscsi_requeue(sp);
 346 #if 0
 347      if(lastcmd != sp->sn.cmd) {
 348           sdebug(1, "resetting CmdSN to=%d (from %d)", lastcmd, sp->sn.cmd);
 349           sp->sn.cmd = lastcmd;
 350      }
 351 #endif
 352      mtx_lock(&sp->io_mtx);
 353      if(sp->flags & ISC_OWAITING) {
 354           wakeup(&sp->flags);
 355      }
 356      mtx_unlock(&sp->io_mtx);
 357
 358      sdebug(2, "restarted sn.cmd=0x%x lastcmd=0x%x", sp->sn.cmd, lastcmd);
 359 }
 360
 361 void
 362 ism_recv(isc_session_t *sp, pduq_t *pq)
 363 {
 364      bhs_t      *bhs;
 365      int        statSN;
 366
 367      debug_called(8);
 368
 369      bhs = &pq->pdu.ipdu.bhs;
 370      statSN = ntohl(bhs->OpcodeSpecificFields[1]);
 371
 372 #ifdef notyet
 373      if(sp->sn.expCmd != sn->cmd) {
 374           sdebug(1, "we lost something ... exp=0x%x cmd=0x%x",
 375                  sn->expCmd, sn->cmd);
 376      }
 377 #endif
 378      sdebug(5, "opcode=0x%x itt=0x%x stat#0x%x maxcmd=0x%0x",
 379             bhs->opcode, ntohl(bhs->itt), statSN, sp->sn.maxCmd);
 380
 381      switch(bhs->opcode) {
 382      case ISCSI_READ_DATA: {
 383           data_in_t     *cmd = &pq->pdu.ipdu.data_in;
 384
 385           if(cmd->S == 0)
 386                break;
 387      }
 388
 389      default:
 390           if(statSN > (sp->sn.stat + 1)) {
 391                sdebug(1, "we lost some rec=0x%x exp=0x%x",
 392                       statSN, sp->sn.stat);
 393                // XXX: must do some error recovery here.
 394           }
 395           sp->sn.stat = statSN;
 396      }
 397
 398      switch(bhs->opcode) {
 399      case ISCSI_LOGIN_RSP:
 400      case ISCSI_TEXT_RSP:
 401      case ISCSI_LOGOUT_RSP:
 402           i_nqueue_rsp(sp, pq);
 403           wakeup(&sp->rsp);
 404           sdebug(3, "wakeup rsp");
 405           break;
 406
 407      case ISCSI_NOP_IN:         _nop_in(sp, pq);        break;
 408      case ISCSI_SCSI_RSP:       _scsi_rsp(sp, pq);      break;
 409      case ISCSI_READ_DATA:      _read_data(sp, pq);     break;
 410      case ISCSI_R2T:            _r2t(sp, pq);           break;
 411      case ISCSI_REJECT:         _reject(sp, pq);        break;
 412      case ISCSI_ASYNC:          _async(sp, pq);         break;
 413
 414      case ISCSI_TASK_RSP:
 415      default:
 416           sdebug(1, "opcode=0x%x itt=0x%x not implemented yet",
 417                  bhs->opcode, ntohl(bhs->itt));
 418           break;
 419      }
 420 }
 421
 422 /*
 423  | go through the out queues looking for work
 424  | if either nothing to do, or window is closed
 425  | return.
 426  */
 427 static int
 428 proc_out(isc_session_t *sp)
 429 {
 430      sn_t       *sn = &sp->sn;
 431      pduq_t     *pq;
 432      int        error, which;
 433
 434      debug_called(8);
 435      error = 0;
 436
 437      while(sp->flags & ISC_LINK_UP) {
 438           pdu_t *pp;
 439           bhs_t *bhs;
 440           /*
 441            | check if there is outstanding work in:
 442            | 1- the Immediate queue
 443            | 2- the R2T queue
 444            | 3- the cmd queue, only if the command window allows it.
 445            */
 446           which = BIT(0) | BIT(1);
 447           if(SNA_GT(sn->cmd, sn->maxCmd) == 0) // if(sn->maxCmd - sn->smc + 1) > 0
 448                which |= BIT(2);
 449
 450           sdebug(4, "which=%d sn->maxCmd=%d sn->cmd=%d", which, sn->maxCmd, sn->cmd);
 451
 452           if((pq = i_dqueue_snd(sp, which)) == NULL)
 453                break;
 454           sdebug(4, "pq=%p", pq);
 455
 456           pp = &pq->pdu;
 457           bhs = &pp->ipdu.bhs;
 458           switch(bhs->opcode) {
 459           case ISCSI_SCSI_CMD:
 460                sn->itt++;
 461                bhs->itt = htonl(sn->itt);
 462
 463           case ISCSI_LOGIN_CMD:
 464           case ISCSI_TEXT_CMD:
 465           case ISCSI_LOGOUT_CMD:
 466           case ISCSI_SNACK:
 467           case ISCSI_NOP_OUT:
 468           case ISCSI_TASK_CMD:
 469                bhs->CmdSN = htonl(sn->cmd);
 470                if(bhs->I == 0)
 471                     sn->cmd++;
 472
 473           case ISCSI_WRITE_DATA:
 474                bhs->ExpStSN = htonl(sn->stat + 1);
 475                break;
 476
 477           default:
 478                // XXX: can this happen?
 479                xdebug("bad opcode=0x%x sn(cmd=0x%x expCmd=0x%x maxCmd=0x%x expStat=0x%x itt=0x%x)",
 480                       bhs->opcode,
 481                       sn->cmd, sn->expCmd, sn->maxCmd, sn->expStat, sn->itt);
 482                // XXX: and now?
 483           }
 484
 485           sdebug(4, "opcode=0x%x sn(cmd=0x%x expCmd=0x%x maxCmd=0x%x expStat=0x%x itt=0x%x)",
 486                 bhs->opcode,
 487                 sn->cmd, sn->expCmd, sn->maxCmd, sn->expStat, sn->itt);
 488
 489           if(bhs->opcode != ISCSI_NOP_OUT)
 490                /*
 491                 | enqued till ack is received
 492                 | note: sosend(...) does not mean the packet left
 493                 | the host so that freeing resources has to wait
 494                 */
 495                i_nqueue_hld(sp, pq);
 496
 497           error = isc_sendPDU(sp, pq);
 498           if(bhs->opcode == ISCSI_NOP_OUT)
 499                pdu_free(sp->isc, pq);
 500           if(error) {
 501                xdebug("error=%d opcode=0x%x ccb=%p itt=%x",
 502                       error, bhs->opcode, pq->ccb, ntohl(bhs->itt));
 503                i_remove_hld(sp, pq);
 504                switch(error) {
 505                case EPIPE:
 506                     sp->flags &= ~ISC_LINK_UP;
 507
 508                case EAGAIN:
 509                     xdebug("requed");
 510                     i_rqueue_pdu(sp, pq);
 511                     break;
 512
 513                default:
 514                     if(pq->ccb) {
 515                          xdebug("back to cam");
 516                          pq->ccb->ccb_h.status |= CAM_REQUEUE_REQ; // some better error?
 517                          xpt_done(pq->ccb);
 518                          pdu_free(sp->isc, pq);
 519                     }
 520                     else
 521                          xdebug("we lost it!");
 522                }
 523           }
 524      }
 525      return error;
 526 }
 527
 528 /*
 529  | survives link breakdowns.
 530  */
 531 static void
 532 ism_out(void *vp)
 533 {
 534      isc_session_t      *sp = (isc_session_t *)vp;
 535      int                error;
 536
 537      debug_called(8);
 538
 539      sp->flags |= ISC_SM_RUNNING;
 540      sdebug(3, "started sp->flags=%x", sp->flags);
 541      do {
 542           if((sp->flags & ISC_HOLD) == 0) {
 543                error = proc_out(sp);
 544                if(error) {
 545                     sdebug(3, "error=%d", error);
 546                }
 547           }
 548           mtx_lock(&sp->io_mtx);
 549           if((sp->flags & ISC_LINK_UP) == 0) {
 550                sdebug(3, "ISC_LINK_UP==0, sp->flags=%x ", sp->flags);
 551                if(sp->soc != NULL)
 552                     sdebug(3, "so_state=%x", sp->soc->so_state);
 553                wakeup(&sp->soc);
 554           }
 555
 556           if(!(sp->flags & ISC_OQNOTEMPTY)) {
 557                sp->flags |= ISC_OWAITING;
 558                if(msleep(&sp->flags, &sp->io_mtx, PRIBIO, "isc_proc", hz*30) == EWOULDBLOCK) {
 559                     if(sp->flags & ISC_CON_RUNNING)
 560                          _nop_out(sp);
 561                }
 562                sp->flags &= ~ISC_OWAITING;
 563           }
 564           sp->flags &= ~ISC_OQNOTEMPTY;
 565           mtx_unlock(&sp->io_mtx);
 566      } while(sp->flags & ISC_SM_RUN);
 567
 568      sp->flags &= ~ISC_SM_RUNNING;
 569      sdebug(3, "dropped ISC_SM_RUNNING");
 570
 571      wakeup(&sp->soc);
 572      wakeup(sp); // XXX: do we need this one?
 573
 574      destroy_dev(sp->dev);
 575
 576      debug(3, "terminated sp=%p sp->sid=%d", sp, sp->sid);
 577
 578      kproc_exit(0);
 579 }
 580
 581 #if 0
 582 static int
 583 isc_dump_options(SYSCTL_HANDLER_ARGS)
 584 {
 585      int error;
 586      isc_session_t *sp;
 587      struct sbuf sb;
 588
 589      sbuf_new_for_sysctl(&sb, NULL, 128, req);
 590
 591      sp = (isc_session_t *)arg1;
 592      sbuf_printf(&sb, "targetname='%s'", sp->opt.targetName);
 593      sbuf_printf(&sb, " targetaddress='%s'", sp->opt.targetAddress);
 594      error = sbuf_finish(&sb);
 595      sbuf_delete(&sb);
 596      return error;
 597 }
 598 #endif
 599
 600 static int
 601 isc_dump_stats(SYSCTL_HANDLER_ARGS)
 602 {
 603      isc_session_t      *sp;
 604      struct isc_softc   *sc;
 605      int        error;
 606      struct sbuf sb;
 607
 608      sp = (isc_session_t *)arg1;
 609      sc = sp->isc;
 610
 611      sbuf_new_for_sysctl(&sb, NULL, 128, req);
 612
 613      sbuf_printf(&sb, "recv=%d sent=%d", sp->stats.nrecv, sp->stats.nsent);
 614      sbuf_printf(&sb, " flags=0x%08x pdus-alloc=%d pdus-max=%d",
 615                  sp->flags, sc->npdu_alloc, sc->npdu_max);
 616      sbuf_printf(&sb, " cws=%d cmd=%x exp=%x max=%x stat=%x itt=%x",
 617                   sp->cws, sp->sn.cmd, sp->sn.expCmd, sp->sn.maxCmd, sp->sn.stat, sp->sn.itt);
 618      error = sbuf_finish(&sb);
 619      sbuf_delete(&sb);
 620      return error;
 621 }
 622
 623 static void
 624 isc_add_sysctls(isc_session_t *sp)
 625 {
 626      debug_called(8);
 627      sdebug(6, "sid=%d %s", sp->sid, devtoname(sp->dev));
 628
 629      sysctl_ctx_init(&sp->clist);
 630      sp->oid = SYSCTL_ADD_NODE(&sp->clist,
 631                                SYSCTL_CHILDREN(sp->isc->oid),
 632                                OID_AUTO,
 633                                devtoname(sp->dev) + 5, // iscsi0
 634                                CTLFLAG_RD | CTLFLAG_MPSAFE,
 635                                0,
 636                                "initiator");
 637      SYSCTL_ADD_PROC(&sp->clist,
 638                      SYSCTL_CHILDREN(sp->oid),
 639                      OID_AUTO,
 640                      "targetname",
 641                      CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 642                      (void *)&sp->opt.targetName, 0,
 643                      sysctl_handle_string, "A", "target name");
 644
 645      SYSCTL_ADD_PROC(&sp->clist,
 646                      SYSCTL_CHILDREN(sp->oid),
 647                      OID_AUTO,
 648                      "targeaddress",
 649                      CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 650                      (void *)&sp->opt.targetAddress, 0,
 651                      sysctl_handle_string, "A", "target address");
 652
 653      SYSCTL_ADD_PROC(&sp->clist,
 654                      SYSCTL_CHILDREN(sp->oid),
 655                      OID_AUTO,
 656                      "stats",
 657                      CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 658                      (void *)sp, 0,
 659                      isc_dump_stats, "A", "statistics");
 660
 661      SYSCTL_ADD_INT(&sp->clist,
 662                      SYSCTL_CHILDREN(sp->oid),
 663                      OID_AUTO,
 664                      "douio",
 665                      CTLFLAG_RW,
 666                      &sp->douio, 0, "enable uio on read");
 667 }
 668
 669 void
 670 ism_stop(isc_session_t *sp)
 671 {
 672      struct isc_softc *sc = sp->isc;
 673      int        n;
 674
 675      debug_called(8);
 676      sdebug(2, "terminating");
 677      /*
 678       | first stop the receiver
 679       */
 680      isc_stop_receiver(sp);
 681      /*
 682       | now stop the xmitter
 683       */
 684      n = 5;
 685      sp->flags &= ~ISC_SM_RUN;
 686      while(n-- && (sp->flags & ISC_SM_RUNNING)) {
 687           sdebug(2, "n=%d", n);
 688           wakeup(&sp->flags);
 689           tsleep(sp, PRIBIO, "-", 5*hz);
 690      }
 691      sdebug(2, "final n=%d", n);
 692      sp->flags &= ~ISC_FFPHASE;
 693
 694      iscsi_cleanup(sp);
 695
 696      (void)i_pdu_flush(sp);
 697
 698      ic_destroy(sp);
 699
 700      sx_xlock(&sc->unit_sx);
 701      free_unr(sc->unit, sp->sid);
 702      sx_xunlock(&sc->unit_sx);
 703
 704      mtx_lock(&sc->isc_mtx);
 705      TAILQ_REMOVE(&sc->isc_sess, sp, sp_link);
 706      sc->nsess--;
 707      mtx_unlock(&sc->isc_mtx);
 708
 709      mtx_destroy(&sp->rsp_mtx);
 710      mtx_destroy(&sp->rsv_mtx);
 711      mtx_destroy(&sp->hld_mtx);
 712      mtx_destroy(&sp->snd_mtx);
 713      mtx_destroy(&sp->io_mtx);
 714
 715      i_freeopt(&sp->opt);
 716
 717      if(sysctl_ctx_free(&sp->clist))
 718           xdebug("sysctl_ctx_free failed");
 719
 720      free(sp, M_ISCSI);
 721 }
 722
 723 int
 724 ism_start(isc_session_t *sp)
 725 {
 726      debug_called(8);
 727     /*
 728      | now is a good time to do some initialization
 729      */
 730      TAILQ_INIT(&sp->rsp);
 731      TAILQ_INIT(&sp->rsv);
 732      TAILQ_INIT(&sp->csnd);
 733      TAILQ_INIT(&sp->isnd);
 734      TAILQ_INIT(&sp->wsnd);
 735      TAILQ_INIT(&sp->hld);
 736
 737      mtx_init(&sp->rsv_mtx, "iscsi-rsv", NULL, MTX_DEF);
 738      mtx_init(&sp->rsp_mtx, "iscsi-rsp", NULL, MTX_DEF);
 739      mtx_init(&sp->snd_mtx, "iscsi-snd", NULL, MTX_DEF);
 740      mtx_init(&sp->hld_mtx, "iscsi-hld", NULL, MTX_DEF);
 741      mtx_init(&sp->io_mtx, "iscsi-io", NULL, MTX_DEF);
 742
 743      isc_add_sysctls(sp);
 744
 745      sp->flags |= ISC_SM_RUN;
 746
 747      debug(4, "starting ism_proc: sp->sid=%d", sp->sid);
 748
 749      return kproc_create(ism_out, sp, &sp->stp, 0, 0, "isc_out %d", sp->sid);
 750 }