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