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.13 2008/07/18 00:07:21 dillon 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/spinlock.h>
  38
  39 #include <sys/thread2.h>
  40 #include <sys/spinlock2.h>
  41 #include <sys/mplock2.h>
  42
  43 #include "cam.h"
  44 #include "cam_ccb.h"
  45 #include "cam_sim.h"
  46 #include "cam_queue.h"
  47 #include "cam_xpt_sim.h"
  48
  49 #define CAM_PATH_ANY (u_int32_t)-1
  50
  51 MALLOC_DEFINE(M_CAMSIM, "CAM SIM", "CAM SIM buffers");
  52
  53 /* Drivers will use sim_mplock if they need the BGL */
  54 sim_lock        sim_mplock;
  55
  56 void
  57 cam_sim_lock(sim_lock *lock)
  58 {
  59         if (lock == &sim_mplock)
  60                 get_mplock();
  61         else
  62                 lockmgr(lock, LK_EXCLUSIVE);
  63 }
  64
  65 void
  66 cam_sim_unlock(sim_lock *lock)
  67 {
  68         if (lock == &sim_mplock)
  69                 rel_mplock();
  70         else
  71                 lockmgr(lock, LK_RELEASE);
  72 }
  73
  74 int
  75 cam_sim_cond_lock(sim_lock *lock)
  76 {
  77         if (lock == &sim_mplock) {
  78                 get_mplock();
  79                 return(1);
  80         } else if (lockstatus(lock, curthread) != LK_EXCLUSIVE) {
  81                 lockmgr(lock, LK_EXCLUSIVE);
  82                 return(1);
  83         }
  84         return(0);
  85 }
  86
  87 void
  88 cam_sim_cond_unlock(sim_lock *lock, int doun)
  89 {
  90         if (doun) {
  91                 if (lock == &sim_mplock)
  92                         rel_mplock();
  93                 else
  94                         lockmgr(lock, LK_RELEASE);
  95         }
  96 }
  97
  98 /*
  99  * lock can be NULL if sim was &dead_sim
 100  */
 101 void
 102 sim_lock_assert_owned(sim_lock *lock)
 103 {
 104         if (lock) {
 105                 if (lock == &sim_mplock)
 106                         ASSERT_MP_LOCK_HELD();
 107                 else
 108                         KKASSERT(lockstatus(lock, curthread) != 0);
 109         }
 110 }
 111
 112 void
 113 sim_lock_assert_unowned(sim_lock *lock)
 114 {
 115         if (lock) {
 116                 if (lock != &sim_mplock)
 117                         KKASSERT(lockstatus(lock, curthread) == 0);
 118         }
 119 }
 120
 121 int
 122 sim_lock_sleep(void *ident, int flags, const char *wmesg, int timo,
 123                sim_lock *lock)
 124 {
 125         int retval;
 126
 127         if (lock != &sim_mplock) {
 128                 /* lock should be held already */
 129                 KKASSERT(lockstatus(lock, curthread) != 0);
 130                 tsleep_interlock(ident, flags);
 131                 lockmgr(lock, LK_RELEASE);
 132                 retval = tsleep(ident, flags | PINTERLOCKED, wmesg, timo);
 133         } else {
 134                 retval = tsleep(ident, flags, wmesg, timo);
 135         }
 136
 137         if (lock != &sim_mplock) {
 138                 lockmgr(lock, LK_EXCLUSIVE);
 139         }
 140
 141         return (retval);
 142 }
 143
 144 struct cam_devq *
 145 cam_simq_alloc(u_int32_t max_sim_transactions)
 146 {
 147         return (cam_devq_alloc(/*size*/0, max_sim_transactions));
 148 }
 149
 150 void
 151 cam_simq_release(struct cam_devq *devq)
 152 {
 153         cam_devq_release(devq);
 154 }
 155
 156 /*
 157  * cam_sim_alloc() may potentially be called from an interrupt (?) but
 158  * unexpected things happen to the system if malloc() returns NULL so we
 159  * use M_INTWAIT anyway.
 160  */
 161 struct cam_sim *
 162 cam_sim_alloc(sim_action_func sim_action, sim_poll_func sim_poll,
 163               const char *sim_name, void *softc, u_int32_t unit,
 164               sim_lock *lock, int max_dev_transactions,
 165               int max_tagged_dev_transactions, struct cam_devq *queue)
 166 {
 167         struct cam_sim *sim;
 168
 169         /*
 170          * XXX ahd was limited to 256 instead of 512 for unknown reasons,
 171          * move that to a global limit here.  We may be able to remove this
 172          * code, needs testing.
 173          */
 174         if (max_dev_transactions > 256)
 175                 max_dev_transactions = 256;
 176         if (max_tagged_dev_transactions > 256)
 177                 max_tagged_dev_transactions = 256;
 178
 179         /*
 180          * Allocate a simq or use the supplied (possibly shared) simq.
 181          */
 182         if (queue == NULL)
 183                 queue = cam_simq_alloc(max_tagged_dev_transactions);
 184         else
 185                 cam_devq_reference(queue);
 186
 187         if (lock == NULL)
 188                 return (NULL);
 189
 190         sim = kmalloc(sizeof(struct cam_sim), M_CAMSIM, M_INTWAIT | M_ZERO);
 191         sim->sim_action = sim_action;
 192         sim->sim_poll = sim_poll;
 193         sim->sim_name = sim_name;
 194         sim->softc = softc;
 195         sim->path_id = CAM_PATH_ANY;
 196         sim->unit_number = unit;
 197         sim->bus_id = 0;        /* set in xpt_bus_register */
 198         sim->max_tagged_dev_openings = max_tagged_dev_transactions;
 199         sim->max_dev_openings = max_dev_transactions;
 200         sim->flags = 0;
 201         sim->refcount = 1;
 202         sim->devq = queue;
 203         sim->lock = lock;
 204         if (lock == &sim_mplock) {
 205                 sim->flags |= 0;
 206                 callout_init(&sim->callout);
 207         } else {
 208                 sim->flags |= CAM_SIM_MPSAFE;
 209                 callout_init_mp(&sim->callout);
 210         }
 211
 212         SLIST_INIT(&sim->ccb_freeq);
 213         TAILQ_INIT(&sim->sim_doneq);
 214         spin_init(&sim->sim_spin);
 215
 216         return (sim);
 217 }
 218
 219 void
 220 cam_sim_set_max_tags(struct cam_sim *sim, int max_tags)
 221 {
 222         if (max_tags > 256)
 223                 max_tags = 256;
 224         sim->max_tagged_dev_openings = max_tags;
 225         cam_devq_set_openings(sim->devq, max_tags);
 226 }
 227
 228 static void deadsim_poll(struct cam_sim *sim);
 229 static void deadsim_action(struct cam_sim *sim, union ccb *ccb);
 230
 231 void
 232 cam_sim_free(struct cam_sim *sim)
 233 {
 234         sim->sim_action = deadsim_action;
 235         sim->sim_poll = deadsim_poll;
 236         cam_sim_release(sim, CAM_SIM_SOFTC);
 237 }
 238
 239 /*
 240  * Note: the devq is still used by individual peripherals even if the
 241  * backend sim disappears, so do not destroy it until the sim itself
 242  * is no longer needed.
 243  */
 244 void
 245 cam_sim_release(struct cam_sim *sim, int flags)
 246 {
 247         if (flags & CAM_SIM_SOFTC)
 248                 sim->softc = NULL;
 249         if (sim->refcount == 1) {
 250                 if (sim->devq) {
 251                         cam_simq_release(sim->devq);
 252                         sim->devq = NULL;
 253                 }
 254                 sim->refcount = 0;
 255                 kfree(sim, M_CAMSIM);
 256         } else {
 257                 --sim->refcount;
 258         }
 259 }
 260
 261 void
 262 cam_sim_set_path(struct cam_sim *sim, u_int32_t path_id)
 263 {
 264         sim->path_id = path_id;
 265 }
 266
 267 /*
 268  * Dead sim poll and action functions.  The backend to the sim has gone
 269  * away, aka usb, scsi device, etc... deal with it.
 270  */
 271 static void
 272 deadsim_poll(struct cam_sim *sim)
 273 {
 274         /* empty */
 275 }
 276
 277 static void
 278 deadsim_action(struct cam_sim *sim, union ccb *ccb)
 279 {
 280         ccb->ccb_h.status = CAM_TID_INVALID;
 281         xpt_done(ccb);
 282 }
 283