sys/bus/cam/cam_sim.c

   1 /*
   2  * Common functions for SCSI Interface Modules (SIMs).
   3  *
   4  * Copyright (c) 1997 Justin T. Gibbs.
   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  *    without modification, immediately at the beginning of the file.
  13  * 2. The name of the author may not be used to endorse or promote products
  14  *    derived from this software without specific prior written permission.
  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 FOR
  20  * 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  * $FreeBSD: src/sys/cam/cam_sim.c,v 1.3 1999/08/28 00:40:42 peter Exp $
  29  * $DragonFly: src/sys/bus/cam/cam_sim.c,v 1.11 2008/05/18 20:30:19 pavalos Exp $
  30  */
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/malloc.h>
  35 #include <sys/kernel.h>
  36 #include <sys/lock.h>
  37 #include <sys/thread2.h>
  38
  39 #include "cam.h"
  40 #include "cam_ccb.h"
  41 #include "cam_sim.h"
  42 #include "cam_queue.h"
  43 #include "cam_xpt_sim.h"
  44
  45 #define CAM_PATH_ANY (u_int32_t)-1
  46
  47 MALLOC_DEFINE(M_CAMSIM, "CAM SIM", "CAM SIM buffers");
  48
  49 /* Drivers will use sim_mplock if they need the BGL */
  50 sim_lock        sim_mplock;
  51
  52 void
  53 cam_sim_lock(sim_lock *lock)
  54 {
  55         if (lock == &sim_mplock)
  56                 get_mplock();
  57         else
  58                 lockmgr(lock, LK_EXCLUSIVE);
  59 }
  60
  61 void
  62 cam_sim_unlock(sim_lock *lock)
  63 {
  64         if (lock == &sim_mplock)
  65                 rel_mplock();
  66         else
  67                 lockmgr(lock, LK_RELEASE);
  68 }
  69
  70 void
  71 sim_lock_assert_owned(sim_lock *lock)
  72 {
  73         if (lock == &sim_mplock)
  74                 ASSERT_MP_LOCK_HELD(curthread);
  75         else
  76                 KKASSERT(lockstatus(lock, curthread) != 0);
  77 }
  78
  79 int
  80 sim_lock_sleep(void *ident, int flags, const char *wmesg, int timo,
  81                sim_lock *lock)
  82 {
  83         int retval;
  84
  85         if (lock != &sim_mplock) {
  86                 /* lock should be held already */
  87                 KKASSERT(lockstatus(lock, curthread) != 0);
  88                 crit_enter();
  89                 tsleep_interlock(ident);
  90                 lockmgr(lock, LK_RELEASE);
  91         }
  92
  93         retval = tsleep(ident, flags, wmesg, timo);
  94
  95         if (lock != &sim_mplock) {
  96                 lockmgr(lock, LK_EXCLUSIVE);
  97                 crit_exit();
  98         }
  99
 100         return (retval);
 101 }
 102
 103 struct cam_devq *
 104 cam_simq_alloc(u_int32_t max_sim_transactions)
 105 {
 106         return (cam_devq_alloc(/*size*/0, max_sim_transactions));
 107 }
 108
 109 void
 110 cam_simq_release(struct cam_devq *devq)
 111 {
 112         cam_devq_release(devq);
 113 }
 114
 115 /*
 116  * cam_sim_alloc() may potentially be called from an interrupt (?) but
 117  * unexpected things happen to the system if malloc() returns NULL so we
 118  * use M_INTWAIT anyway.
 119  */
 120 struct cam_sim *
 121 cam_sim_alloc(sim_action_func sim_action, sim_poll_func sim_poll,
 122               const char *sim_name, void *softc, u_int32_t unit,
 123               sim_lock *lock, int max_dev_transactions,
 124               int max_tagged_dev_transactions, struct cam_devq *queue)
 125 {
 126         struct cam_sim *sim;
 127
 128         /*
 129          * XXX ahd was limited to 256 instead of 512 for unknown reasons,
 130          * move that to a global limit here.  We may be able to remove this
 131          * code, needs testing.
 132          */
 133         if (max_dev_transactions > 256)
 134                 max_dev_transactions = 256;
 135         if (max_tagged_dev_transactions > 256)
 136                 max_tagged_dev_transactions = 256;
 137
 138         /*
 139          * Allocate a simq or use the supplied (possibly shared) simq.
 140          */
 141         if (queue == NULL)
 142                 queue = cam_simq_alloc(max_tagged_dev_transactions);
 143         else
 144                 cam_devq_reference(queue);
 145
 146         if (lock == NULL)
 147                 return (NULL);
 148
 149         sim = kmalloc(sizeof(struct cam_sim), M_CAMSIM, M_INTWAIT | M_ZERO);
 150         sim->sim_action = sim_action;
 151         sim->sim_poll = sim_poll;
 152         sim->sim_name = sim_name;
 153         sim->softc = softc;
 154         sim->path_id = CAM_PATH_ANY;
 155         sim->unit_number = unit;
 156         sim->bus_id = 0;        /* set in xpt_bus_register */
 157         sim->max_tagged_dev_openings = max_tagged_dev_transactions;
 158         sim->max_dev_openings = max_dev_transactions;
 159         sim->flags = 0;
 160         sim->refcount = 1;
 161         sim->devq = queue;
 162         sim->lock = lock;
 163         if (lock == &sim_mplock) {
 164                 sim->flags |= 0;
 165                 callout_init(&sim->callout);
 166         } else {
 167                 sim->flags |= CAM_SIM_MPSAFE;
 168                 callout_init_mp(&sim->callout);
 169         }
 170
 171         SLIST_INIT(&sim->ccb_freeq);
 172         TAILQ_INIT(&sim->sim_doneq);
 173
 174         return (sim);
 175 }
 176
 177 static void deadsim_poll(struct cam_sim *sim);
 178 static void deadsim_action(struct cam_sim *sim, union ccb *ccb);
 179
 180 void
 181 cam_sim_free(struct cam_sim *sim)
 182 {
 183         sim->sim_action = deadsim_action;
 184         sim->sim_poll = deadsim_poll;
 185         cam_sim_release(sim, CAM_SIM_SOFTC);
 186 }
 187
 188 /*
 189  * Note: the devq is still used by individual peripherals even if the
 190  * backend sim disappears, so do not destroy it until the sim itself
 191  * is no longer needed.
 192  */
 193 void
 194 cam_sim_release(struct cam_sim *sim, int flags)
 195 {
 196         if (flags & CAM_SIM_SOFTC)
 197                 sim->softc = NULL;
 198         if (sim->refcount == 1) {
 199                 if (sim->devq) {
 200                         cam_simq_release(sim->devq);
 201                         sim->devq = NULL;
 202                 }
 203                 sim->refcount = 0;
 204                 kfree(sim, M_CAMSIM);
 205         } else {
 206                 --sim->refcount;
 207         }
 208 }
 209
 210 void
 211 cam_sim_set_path(struct cam_sim *sim, u_int32_t path_id)
 212 {
 213         sim->path_id = path_id;
 214 }
 215
 216 /*
 217  * Dead sim poll and action functions.  The backend to the sim has gone
 218  * away, aka usb, scsi device, etc... deal with it.
 219  */
 220 static void
 221 deadsim_poll(struct cam_sim *sim)
 222 {
 223         /* empty */
 224 }
 225
 226 static void
 227 deadsim_action(struct cam_sim *sim, union ccb *ccb)
 228 {
 229         ccb->ccb_h.status = CAM_TID_INVALID;
 230         xpt_done(ccb);
 231 }
 232