sys/cam/ctl/ctl_frontend.c

   1 /*-
   2  * Copyright (c) 2003 Silicon Graphics International Corp.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions, and the following disclaimer,
  10  *    without modification.
  11  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  12  *    substantially similar to the "NO WARRANTY" disclaimer below
  13  *    ("Disclaimer") and any redistribution must be conditioned upon
  14  *    including a substantially similar Disclaimer requirement for further
  15  *    binary redistribution.
  16  *
  17  * NO WARRANTY
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  26  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  27  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGES.
  29  *
  30  * $Id: //depot/users/kenm/FreeBSD-test2/sys/cam/ctl/ctl_frontend.c#4 $
  31  */
  32 /*
  33  * CAM Target Layer front end interface code
  34  *
  35  * Author: Ken Merry <ken@FreeBSD.org>
  36  */
  37
  38 #include <sys/cdefs.h>
  39 __FBSDID("$FreeBSD$");
  40
  41 #include <sys/param.h>
  42 #include <sys/systm.h>
  43 #include <sys/kernel.h>
  44 #include <sys/types.h>
  45 #include <sys/malloc.h>
  46 #include <sys/lock.h>
  47 #include <sys/mutex.h>
  48 #include <sys/condvar.h>
  49 #include <sys/endian.h>
  50 #include <sys/queue.h>
  51 #include <sys/sysctl.h>
  52
  53 #include <cam/scsi/scsi_all.h>
  54 #include <cam/scsi/scsi_da.h>
  55 #include <cam/ctl/ctl_io.h>
  56 #include <cam/ctl/ctl.h>
  57 #include <cam/ctl/ctl_frontend.h>
  58 #include <cam/ctl/ctl_frontend_internal.h>
  59 #include <cam/ctl/ctl_backend.h>
  60 /* XXX KDM move defines from ctl_ioctl.h to somewhere else */
  61 #include <cam/ctl/ctl_ioctl.h>
  62 #include <cam/ctl/ctl_ha.h>
  63 #include <cam/ctl/ctl_private.h>
  64 #include <cam/ctl/ctl_debug.h>
  65
  66 extern struct ctl_softc *control_softc;
  67
  68 int
  69 ctl_frontend_register(struct ctl_frontend *fe, int master_shelf)
  70 {
  71         struct ctl_io_pool *pool;
  72         int port_num;
  73         int retval;
  74
  75         retval = 0;
  76
  77         KASSERT(control_softc != NULL, ("CTL is not initialized"));
  78
  79         mtx_lock(&control_softc->ctl_lock);
  80         port_num = ctl_ffz(&control_softc->ctl_port_mask, CTL_MAX_PORTS);
  81         if ((port_num == -1)
  82          || (ctl_set_mask(&control_softc->ctl_port_mask, port_num) == -1)) {
  83                 fe->targ_port = -1;
  84                 mtx_unlock(&control_softc->ctl_lock);
  85                 return (1);
  86         }
  87         control_softc->num_frontends++;
  88
  89         mtx_unlock(&control_softc->ctl_lock);
  90         /*
  91          * We add 20 to whatever the caller requests, so he doesn't get
  92          * burned by queueing things back to the pending sense queue.  In
  93          * theory, there should probably only be one outstanding item, at
  94          * most, on the pending sense queue for a LUN.  We'll clear the
  95          * pending sense queue on the next command, whether or not it is
  96          * a REQUEST SENSE.
  97          */
  98         retval = ctl_pool_create(control_softc,
  99                                  (fe->port_type != CTL_PORT_IOCTL) ?
 100                                  CTL_POOL_FETD : CTL_POOL_IOCTL,
 101                                  fe->num_requested_ctl_io + 20, &pool);
 102         if (retval != 0) {
 103                 fe->targ_port = -1;
 104                 mtx_lock(&control_softc->ctl_lock);
 105                 ctl_clear_mask(&control_softc->ctl_port_mask, port_num);
 106                 mtx_unlock(&control_softc->ctl_lock);
 107                 return (retval);
 108         }
 109
 110         mtx_lock(&control_softc->ctl_lock);
 111
 112         /* For now assume master shelf */
 113         //fe->targ_port = port_num;
 114         fe->targ_port = port_num + (master_shelf!=0 ? 0 : CTL_MAX_PORTS);
 115         fe->max_initiators = CTL_MAX_INIT_PER_PORT;
 116         STAILQ_INSERT_TAIL(&control_softc->fe_list, fe, links);
 117         ctl_pool_acquire(pool);
 118         control_softc->ctl_ports[port_num] = fe;
 119
 120         mtx_unlock(&control_softc->ctl_lock);
 121
 122         fe->ctl_pool_ref = pool;
 123
 124         return (retval);
 125 }
 126
 127 int
 128 ctl_frontend_deregister(struct ctl_frontend *fe)
 129 {
 130         struct ctl_io_pool *pool;
 131         int port_num;
 132         int retval;
 133
 134         retval = 0;
 135
 136         pool = (struct ctl_io_pool *)fe->ctl_pool_ref;
 137
 138         if (fe->targ_port == -1) {
 139                 retval = 1;
 140                 goto bailout;
 141         }
 142
 143         mtx_lock(&control_softc->ctl_lock);
 144
 145         ctl_pool_invalidate(pool);
 146         ctl_pool_release(pool);
 147
 148         STAILQ_REMOVE(&control_softc->fe_list, fe, ctl_frontend, links);
 149         control_softc->num_frontends--;
 150         port_num = (fe->targ_port < CTL_MAX_PORTS) ? fe->targ_port :
 151                                                      fe->targ_port - CTL_MAX_PORTS;
 152         ctl_clear_mask(&control_softc->ctl_port_mask, port_num);
 153         control_softc->ctl_ports[port_num] = NULL;
 154         mtx_unlock(&control_softc->ctl_lock);
 155 bailout:
 156         return (retval);
 157 }
 158
 159 void
 160 ctl_frontend_set_wwns(struct ctl_frontend *fe, int wwnn_valid, uint64_t wwnn,
 161                       int wwpn_valid, uint64_t wwpn)
 162 {
 163         if (wwnn_valid)
 164                 fe->wwnn = wwnn;
 165
 166         if (wwpn_valid)
 167                 fe->wwpn = wwpn;
 168 }
 169
 170 void
 171 ctl_frontend_online(struct ctl_frontend *fe)
 172 {
 173         fe->port_online(fe->onoff_arg);
 174         /* XXX KDM need a lock here? */
 175         fe->status |= CTL_PORT_STATUS_ONLINE;
 176 }
 177
 178 void
 179 ctl_frontend_offline(struct ctl_frontend *fe)
 180 {
 181         fe->port_offline(fe->onoff_arg);
 182         /* XXX KDM need a lock here? */
 183         fe->status &= ~CTL_PORT_STATUS_ONLINE;
 184 }
 185
 186 /*
 187  * vim: ts=8
 188  */