xref: /freebsd/sys/cam/cam_queue.h (revision 282a3889ebf826db9839be296ff1dd903f6d6d6e)
1 /*-
2  * CAM request queue management definitions.
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$
29  */
30 
31 #ifndef _CAM_CAM_QUEUE_H
32 #define _CAM_CAM_QUEUE_H 1
33 
34 #ifdef _KERNEL
35 
36 #include <sys/queue.h>
37 
38 /*
39  * This structure implements a heap based priority queue.  The queue
40  * assumes that the objects stored in it begin with a cam_qentry
41  * structure holding the priority information used to sort the objects.
42  * This structure is opaque to clients (outside of the XPT layer) to allow
43  * the implementation to change without affecting them.
44  */
45 struct camq {
46 	cam_pinfo **queue_array;
47 	int	   array_size;
48 	int	   entries;
49 	u_int32_t  generation;
50 	u_int32_t  qfrozen_cnt;
51 };
52 
53 TAILQ_HEAD(ccb_hdr_tailq, ccb_hdr);
54 LIST_HEAD(ccb_hdr_list, ccb_hdr);
55 SLIST_HEAD(ccb_hdr_slist, ccb_hdr);
56 
57 struct cam_ccbq {
58 	struct	camq queue;
59 	int	devq_openings;
60 	int	dev_openings;
61 	int	dev_active;
62 	int	held;
63 	struct	ccb_hdr_tailq active_ccbs;
64 };
65 
66 struct cam_ed;
67 
68 struct cam_devq {
69 	struct	camq alloc_queue;
70 	struct	camq send_queue;
71 	struct	cam_ed *active_dev;
72 	int	alloc_openings;
73 	int	alloc_active;
74 	int	send_openings;
75 	int	send_active;
76 };
77 
78 
79 struct cam_devq *cam_devq_alloc(int devices, int openings);
80 
81 int		 cam_devq_init(struct cam_devq *devq, int devices,
82 			       int openings);
83 
84 void		 cam_devq_free(struct cam_devq *devq);
85 
86 u_int32_t	 cam_devq_resize(struct cam_devq *camq, int openings);
87 
88 /*
89  * Allocate a cam_ccb_queue structure and initialize it.
90  */
91 struct cam_ccbq	*cam_ccbq_alloc(int openings);
92 
93 u_int32_t	cam_ccbq_resize(struct cam_ccbq *ccbq, int devices);
94 
95 int		cam_ccbq_init(struct cam_ccbq *ccbq, int openings);
96 
97 void		cam_ccbq_free(struct cam_ccbq *ccbq);
98 
99 void		cam_ccbq_fini(struct cam_ccbq *ccbq);
100 
101 /*
102  * Allocate and initialize a cam_queue structure.
103  */
104 struct camq	*camq_alloc(int size);
105 
106 /*
107  * Resize a cam queue
108  */
109 u_int32_t	camq_resize(struct camq *queue, int new_size);
110 
111 /*
112  * Initialize a camq structure.  Return 0 on success, 1 on failure.
113  */
114 int		camq_init(struct camq *camq, int size);
115 
116 /*
117  * Free a cam_queue structure.  This should only be called if a controller
118  * driver failes somehow during its attach routine or is unloaded and has
119  * obtained a cam_queue structure.
120  */
121 void		camq_free(struct camq *queue);
122 
123 /*
124  * Finialize any internal storage or state of a cam_queue.
125  */
126 void		camq_fini(struct camq *queue);
127 
128 /*
129  * cam_queue_insert: Given a CAM queue with at least one open spot,
130  * insert the new entry maintaining order.
131  */
132 void		camq_insert(struct camq *queue, cam_pinfo *new_entry);
133 
134 /*
135  * camq_remove: Remove and arbitrary entry from the queue maintaining
136  * queue order.
137  */
138 cam_pinfo	*camq_remove(struct camq *queue, int index);
139 #define CAMQ_HEAD 1	/* Head of queue index */
140 
141 /* Index the first element in the heap */
142 #define CAMQ_GET_HEAD(camq) ((camq)->queue_array[CAMQ_HEAD])
143 
144 /*
145  * camq_change_priority: Raise or lower the priority of an entry
146  * maintaining queue order.
147  */
148 void		camq_change_priority(struct camq *queue, int index,
149 				     u_int32_t new_priority);
150 
151 static __inline int
152 cam_ccbq_pending_ccb_count(struct cam_ccbq *ccbq);
153 
154 static __inline void
155 cam_ccbq_take_opening(struct cam_ccbq *ccbq);
156 
157 static __inline void
158 cam_ccbq_insert_ccb(struct cam_ccbq *ccbq, union ccb *new_ccb);
159 
160 static __inline void
161 cam_ccbq_remove_ccb(struct cam_ccbq *ccbq, union ccb *ccb);
162 
163 static __inline union ccb *
164 cam_ccbq_peek_ccb(struct cam_ccbq *ccbq, int index);
165 
166 static __inline void
167 cam_ccbq_send_ccb(struct cam_ccbq *queue, union ccb *send_ccb);
168 
169 static __inline void
170 cam_ccbq_ccb_done(struct cam_ccbq *ccbq, union ccb *done_ccb);
171 
172 static __inline void
173 cam_ccbq_release_opening(struct cam_ccbq *ccbq);
174 
175 
176 static __inline int
177 cam_ccbq_pending_ccb_count(struct cam_ccbq *ccbq)
178 {
179 	return (ccbq->queue.entries);
180 }
181 
182 static __inline void
183 cam_ccbq_take_opening(struct cam_ccbq *ccbq)
184 {
185 	ccbq->devq_openings--;
186 	ccbq->held++;
187 }
188 
189 static __inline void
190 cam_ccbq_insert_ccb(struct cam_ccbq *ccbq, union ccb *new_ccb)
191 {
192 	ccbq->held--;
193 	camq_insert(&ccbq->queue, &new_ccb->ccb_h.pinfo);
194 }
195 
196 static __inline void
197 cam_ccbq_remove_ccb(struct cam_ccbq *ccbq, union ccb *ccb)
198 {
199 	camq_remove(&ccbq->queue, ccb->ccb_h.pinfo.index);
200 }
201 
202 static __inline union ccb *
203 cam_ccbq_peek_ccb(struct cam_ccbq *ccbq, int index)
204 {
205 	return((union ccb *)ccbq->queue.queue_array[index]);
206 }
207 
208 static __inline void
209 cam_ccbq_send_ccb(struct cam_ccbq *ccbq, union ccb *send_ccb)
210 {
211 
212 	TAILQ_INSERT_TAIL(&ccbq->active_ccbs,
213 			  &(send_ccb->ccb_h),
214 			  xpt_links.tqe);
215 	send_ccb->ccb_h.pinfo.index = CAM_ACTIVE_INDEX;
216 	ccbq->dev_active++;
217 	ccbq->dev_openings--;
218 }
219 
220 static __inline void
221 cam_ccbq_ccb_done(struct cam_ccbq *ccbq, union ccb *done_ccb)
222 {
223 	TAILQ_REMOVE(&ccbq->active_ccbs, &done_ccb->ccb_h,
224 		     xpt_links.tqe);
225 	ccbq->dev_active--;
226 	ccbq->dev_openings++;
227 	ccbq->held++;
228 }
229 
230 static __inline void
231 cam_ccbq_release_opening(struct cam_ccbq *ccbq)
232 {
233 	ccbq->held--;
234 	ccbq->devq_openings++;
235 }
236 
237 #endif /* _KERNEL */
238 #endif  /* _CAM_CAM_QUEUE_H */
239