Print this page
3862 stmf + kstat = kernel panic
3863 stmf_itl_task_start() must check for ilu->ilu_kstat_io is non-null
3864 memory leak in the iSCSI code
Reviewed by: Adam Leventhal <ahl@delphix.com>
Reviewed by: Jeremy Jones <jeremy@delphix.com>
Reviewed by: Sebastien Roy <sebastien.roy@delphix.com>
Reviewed by: Dan McDonald <danmcd@nexenta.com>
Reviewed by: Garrett D'Amore <garrett@damore.org>
Reviewed by: Richard Elling <richard.elling@gmail.com>
Approved by: Gordon Ross <gwr@nexenta.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/sys/stmf.h
+++ new/usr/src/uts/common/sys/stmf.h
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
23 + * Copyright (c) 2013 by Delphix. All rights reserved.
23 24 */
24 25 #ifndef _STMF_H
25 26 #define _STMF_H
26 27
27 28 #include <sys/stmf_defines.h>
28 29
29 30 #ifdef __cplusplus
30 31 extern "C" {
31 32 #endif
32 33
33 34 typedef enum stmf_struct_id {
34 35 STMF_STRUCT_LU_PROVIDER = 1,
35 36 STMF_STRUCT_PORT_PROVIDER,
36 37 STMF_STRUCT_STMF_LOCAL_PORT,
37 38 STMF_STRUCT_STMF_LU,
38 39 STMF_STRUCT_SCSI_SESSION,
39 40 STMF_STRUCT_SCSI_TASK,
40 41 STMF_STRUCT_DATA_BUF,
41 42 STMF_STRUCT_DBUF_STORE,
42 43 STMF_MAX_STRUCT_IDS
43 44 } stmf_struct_id_t;
44 45
45 46 /*
46 47 * Provider callback commands
47 48 */
48 49 #define STMF_PROVIDER_DATA_UPDATED 0x01
49 50
50 51 /*
51 52 * Provider callback flags
52 53 */
53 54 #define STMF_PCB_STMF_ONLINING 0x0001
54 55 #define STMF_PCB_PREG_COMPLETE 0x0002
55 56
56 57 typedef void *data_seg_handle_t;
57 58 #define STMF_MAX_LU_CACHE_NTASKS 16
58 59
59 60 #define STMF_NO_HANDLE 0xffffffff
60 61
61 62 #define COMPANY_ID_NONE 0xFFFFFFFF
62 63 #define COMPANY_ID_SUN 0x00144F
63 64
64 65 /*
65 66 * The scatter/gather list buffer format is used in 2 different
66 67 * contexts within stmf:
67 68 * 1) supplied by the port provider that the LU provider uses to exchange
68 69 * data with the backing store.
69 70 * 2) supplied by the LU provider that the port provider uses exchange
70 71 * data with the host initiator.
71 72 * The second format is optionally supported by the port provided as
72 73 * indicated by the command task flags.
73 74 */
74 75
75 76 typedef struct stmf_sglist_ent {
76 77 uint32_t seg_length;
77 78 uint8_t *seg_addr;
78 79 } stmf_sglist_ent_t;
79 80
80 81 typedef struct stmf_data_buf {
81 82 void *db_stmf_private;
82 83 void *db_port_private;
83 84 void *db_lu_private;
84 85 uint32_t db_buf_size; /* Total size of this buffer */
85 86 uint32_t db_data_size; /* Intended xfer size of this buffer */
86 87 uint32_t db_relative_offset;
87 88 uint16_t db_sglist_length;
88 89 uint16_t db_flags; /* Direction, auto status etc */
89 90 stmf_status_t db_xfer_status;
90 91 uint8_t db_handle; /* To track parallel buffers */
91 92 hrtime_t db_xfer_start_timestamp;
92 93 stmf_sglist_ent_t db_sglist[1]; /* PP scatter/gather list */
93 94 } stmf_data_buf_t;
94 95
95 96 /*
96 97 * db_flags
97 98 */
98 99 #define DB_DIRECTION_TO_RPORT 0x0001
99 100 #define DB_DIRECTION_FROM_RPORT 0x0002
100 101 #define DB_SEND_STATUS_GOOD 0x0004
101 102 #define DB_STATUS_GOOD_SENT 0x0008
102 103 #define DB_DONT_CACHE 0x0010
103 104 #define DB_DONT_REUSE 0x0020
104 105 #define DB_LU_DATA_BUF 0x0040
105 106 #define DB_LPORT_XFER_ACTIVE 0x8000
106 107
107 108 typedef struct scsi_task {
108 109 void *task_stmf_private;
109 110 void *task_port_private;
110 111
111 112 void *task_lu_private;
112 113 struct stmf_scsi_session *task_session;
113 114 struct stmf_local_port *task_lport;
114 115 struct stmf_lu *task_lu;
115 116 void *task_lu_itl_handle; /* Assigned by LU */
116 117
117 118 /* CMD information from initiator */
118 119 uint8_t task_lun_no[8];
119 120 uint8_t task_flags; /* See def. for task flags */
120 121 uint8_t task_priority; /* As per SAM-3 */
121 122 uint8_t task_mgmt_function; /* If this is a TM request */
122 123 uint8_t task_max_nbufs;
123 124 uint8_t task_cur_nbufs;
124 125 uint8_t task_csn_size; /* cmd seq no size in bits */
125 126 uint16_t task_additional_flags;
126 127 uint32_t task_cmd_seq_no;
127 128 uint32_t task_expected_xfer_length;
128 129 uint32_t task_timeout; /* In seconds */
129 130 uint16_t task_ext_id;
130 131 uint16_t task_cdb_length;
131 132 uint8_t *task_cdb;
132 133
133 134 /* Fields to manage data phase */
134 135 uint32_t task_cmd_xfer_length; /* xfer len based on CDB */
135 136 uint32_t task_nbytes_transferred;
136 137 uint32_t task_max_xfer_len; /* largest xfer allowed */
137 138 uint32_t task_1st_xfer_len; /* 1st xfer hint */
138 139 uint32_t task_copy_threshold; /* copy reduction threshold */
139 140
140 141
141 142 /* Status Phase */
142 143 stmf_status_t task_completion_status;
143 144 uint32_t task_resid;
144 145 uint8_t task_status_ctrl; /* See def. for status ctrl */
145 146 uint8_t task_scsi_status;
146 147 uint16_t task_sense_length;
147 148 uint8_t *task_sense_data;
148 149
149 150 /* Misc. task data */
150 151 void *task_extended_cmd;
151 152
152 153 } scsi_task_t;
153 154
154 155 /*
155 156 * Maximum expected transfer length. Can also be used when the transfer
156 157 * length is unknown when the task is allocated (e.g. SAS)
157 158 */
158 159
159 160 #define TASK_MAX_XFER_LENGTH 0xFFFFFFFF
160 161
161 162 /*
162 163 * task_flags definitions.
163 164 */
164 165 /*
165 166 * If TF_INITIAL_BURST is set, the dbuf passed with new_task() contains
166 167 * data from initial burst. Otherwise its just a buffer which the port
167 168 * passed to the LU.
168 169 */
169 170 #define TF_INITIAL_BURST 0x80
170 171 /* Both READ_DATA and WRITE_DATA can be set for bidirectional xfers */
171 172 #define TF_READ_DATA 0x40
172 173 #define TF_WRITE_DATA 0x20
173 174 #define TF_ATTR_MASK 0x07
174 175 #define TF_ATTR_UNTAGGED 0x0
175 176 #define TF_ATTR_SIMPLE_QUEUE 0x1
176 177 #define TF_ATTR_ORDERED_QUEUE 0x2
177 178 #define TF_ATTR_HEAD_OF_QUEUE 0x3
178 179 #define TF_ATTR_ACA 0x4
179 180
180 181 /*
181 182 * Task Management flags.
182 183 */
183 184 #define TM_NONE 0x00
184 185 #define TM_ABORT_TASK 0x01
185 186 #define TM_ABORT_TASK_SET 0x02
186 187 #define TM_CLEAR_ACA 0x03
187 188 #define TM_CLEAR_TASK_SET 0x04
188 189 #define TM_LUN_RESET 0x05
189 190 #define TM_TARGET_WARM_RESET 0x06
190 191 #define TM_TARGET_COLD_RESET 0x07
191 192 #define TM_TASK_REASSIGN 0x08
192 193 #define TM_TARGET_RESET 0x09
193 194 #define TM_QUERY_TASK 0x0A
194 195
195 196 /*
196 197 * additional flags
197 198 */
198 199 #define TASK_AF_ENABLE_COMP_CONF 0x01
199 200 #define TASK_AF_PORT_LOAD_HIGH 0x02
200 201 #define TASK_AF_NO_EXPECTED_XFER_LENGTH 0x04
201 202 /*
202 203 * PP sets this flag if it can process dbufs created by the LU.
203 204 */
204 205 #define TASK_AF_ACCEPT_LU_DBUF 0x08
205 206
206 207 /*
207 208 * scsi_task_t extension identifiers
208 209 */
209 210 #define STMF_TASK_EXT_NONE 0
210 211
211 212 /*
212 213 * max_nbufs
213 214 */
214 215 #define STMF_BUFS_MAX 255
215 216
216 217 /*
217 218 * Task status ctrl
218 219 */
219 220 #define TASK_SCTRL_OVER 1
220 221 #define TASK_SCTRL_UNDER 2
221 222
222 223 /*
223 224 * The flags used by I/O flow.
224 225 */
225 226 #define STMF_IOF_LU_DONE 0x0001
226 227 #define STMF_IOF_LPORT_DONE 0x0002
227 228 #define STMF_IOF_STATS_ONLY 0x0004
228 229
229 230 /*
230 231 * struct allocation flags
231 232 */
232 233 #define AF_FORCE_NOSLEEP 0x0001
233 234 #define AF_DONTZERO 0x0002
234 235
235 236 typedef struct stmf_state_change_info {
236 237 uint64_t st_rflags; /* Reason behind this change */
237 238 char *st_additional_info;
238 239 } stmf_state_change_info_t;
239 240
240 241 typedef struct stmf_change_status {
241 242 stmf_status_t st_completion_status;
242 243 char *st_additional_info;
243 244 } stmf_change_status_t;
244 245
245 246 /*
246 247 * conditions causing or affecting the change.
247 248 */
248 249 #define STMF_RFLAG_USER_REQUEST 0x0001
249 250 #define STMF_RFLAG_FATAL_ERROR 0x0002
250 251 #define STMF_RFLAG_STAY_OFFLINED 0x0004
251 252 #define STMF_RFLAG_RESET 0x0008
252 253 #define STMF_RFLAG_COLLECT_DEBUG_DUMP 0x0010
253 254 #define STMF_RFLAG_LU_ABORT 0x0020
254 255 #define STMF_RFLAG_LPORT_ABORT 0x0040
255 256
256 257 #define STMF_CHANGE_INFO_LEN 160
257 258
258 259 /*
259 260 * cmds to stmf_abort entry point
260 261 */
261 262 #define STMF_QUEUE_TASK_ABORT 1
262 263 #define STMF_REQUEUE_TASK_ABORT_LPORT 2
263 264 #define STMF_REQUEUE_TASK_ABORT_LU 3
264 265 #define STMF_QUEUE_ABORT_LU 4
265 266
266 267 /*
267 268 * cmds to be used by stmf ctl
268 269 */
269 270 #define STMF_CMD_LU_OP 0x0100
270 271 #define STMF_CMD_LPORT_OP 0x0200
271 272 #define STMF_CMD_MASK 0x00ff
272 273 #define STMF_CMD_ONLINE 0x0001
273 274 #define STMF_CMD_OFFLINE 0x0002
274 275 #define STMF_CMD_GET_STATUS 0x0003
275 276 #define STMF_CMD_ONLINE_COMPLETE 0x0004
276 277 #define STMF_CMD_OFFLINE_COMPLETE 0x0005
277 278 #define STMF_ACK_ONLINE_COMPLETE 0x0006
278 279 #define STMF_ACK_OFFLINE_COMPLETE 0x0007
279 280
280 281 #define STMF_CMD_LU_ONLINE (STMF_CMD_LU_OP | STMF_CMD_ONLINE)
281 282 #define STMF_CMD_LU_OFFLINE (STMF_CMD_LU_OP | STMF_CMD_OFFLINE)
282 283 #define STMF_CMD_LPORT_ONLINE (STMF_CMD_LPORT_OP | STMF_CMD_ONLINE)
283 284 #define STMF_CMD_LPORT_OFFLINE (STMF_CMD_LPORT_OP | STMF_CMD_OFFLINE)
284 285 #define STMF_CMD_GET_LU_STATUS (STMF_CMD_LU_OP | STMF_CMD_GET_STATUS)
285 286 #define STMF_CMD_GET_LPORT_STATUS \
286 287 (STMF_CMD_LPORT_OP | STMF_CMD_GET_STATUS)
287 288 #define STMF_CMD_LU_ONLINE_COMPLETE \
288 289 (STMF_CMD_LU_OP | STMF_CMD_ONLINE_COMPLETE)
289 290 #define STMF_CMD_LPORT_ONLINE_COMPLETE \
290 291 (STMF_CMD_LPORT_OP | STMF_CMD_ONLINE_COMPLETE)
291 292 #define STMF_ACK_LU_ONLINE_COMPLETE \
292 293 (STMF_CMD_LU_OP | STMF_ACK_ONLINE_COMPLETE)
293 294 #define STMF_ACK_LPORT_ONLINE_COMPLETE \
294 295 (STMF_CMD_LPORT_OP | STMF_ACK_ONLINE_COMPLETE)
295 296 #define STMF_CMD_LU_OFFLINE_COMPLETE \
296 297 (STMF_CMD_LU_OP | STMF_CMD_OFFLINE_COMPLETE)
297 298 #define STMF_CMD_LPORT_OFFLINE_COMPLETE \
298 299 (STMF_CMD_LPORT_OP | STMF_CMD_OFFLINE_COMPLETE)
299 300 #define STMF_ACK_LU_OFFLINE_COMPLETE \
300 301 (STMF_CMD_LU_OP | STMF_ACK_OFFLINE_COMPLETE)
301 302 #define STMF_ACK_LPORT_OFFLINE_COMPLETE \
302 303 (STMF_CMD_LPORT_OP | STMF_ACK_OFFLINE_COMPLETE)
303 304 /*
304 305 * For LPORTs and LUs to create their own ctl cmds which dont
305 306 * conflict with stmf ctl cmds.
306 307 */
307 308 #define STMF_LPORT_CTL_CMDS 0x1000
308 309 #define STMF_LU_CTL_CMDS 0x2000
309 310
310 311 /*
311 312 * Commands for various info routines.
312 313 */
313 314 /* Command classifiers */
314 315 #define SI_LPORT 0x1000000
315 316 #define SI_STMF 0x2000000
316 317 #define SI_LU 0x4000000
317 318 #define SI_LPORT_FC 0x0000000
318 319 #define SI_LPORT_ISCSI 0x0010000
319 320 #define SI_LPORT_SAS 0x0020000
320 321 #define SI_STMF_LU 0x0010000
321 322 #define SI_STMF_LPORT 0x0020000
322 323
323 324 #define SI_GET_CLASS(v) ((v) & 0xFF000000)
324 325 #define SI_GET_SUBCLASS(v) ((v) & 0x00FF0000)
325 326
326 327 /* Commands for LPORT info routines */
327 328 /* XXX - Implement these. */
328 329 #if 0
329 330 #define SI_LPORT_FC_PORTINFO (SI_LPORT | SI_LPORT_FC | 1)
330 331 #define SI_RPORT_FC_PORTINFO (SI_LPORT | SI_LPORT_FC | 2)
331 332 #endif
332 333
333 334 /*
334 335 * Events
335 336 */
336 337 #define STMF_EVENT_ALL ((int)-1)
337 338 #define LPORT_EVENT_INITIAL_LUN_MAPPED 0
338 339
339 340 /*
340 341 * This needs to go into common/ddi/sunddi.h
341 342 */
342 343 #define DDI_NT_STMF "ddi_scsi_target:framework"
343 344 #define DDI_NT_STMF_LP "ddi_scsi_target:lu_provider"
344 345 #define DDI_NT_STMF_PP "ddi_scsi_target:port_provider"
345 346
346 347 /*
347 348 * VPD page bits.
348 349 */
349 350 #define STMF_VPD_LU_ID 0x01
350 351 #define STMF_VPD_TARGET_ID 0x02
351 352 #define STMF_VPD_TP_GROUP 0x04
352 353 #define STMF_VPD_RELATIVE_TP_ID 0x08
353 354
354 355 /*
355 356 * Common macros to simplify coding
356 357 */
357 358 #define STMF_SEC2TICK(x_sec) (drv_usectohz((x_sec) * 1000000))
358 359
359 360 void stmf_trace(caddr_t ident, const char *fmt, ...);
360 361 void *stmf_alloc(stmf_struct_id_t sid, int additional_size, int alloc_flags);
361 362 void stmf_free(void *struct_ptr);
362 363 struct scsi_task *stmf_task_alloc(struct stmf_local_port *lport,
363 364 struct stmf_scsi_session *ss, uint8_t *lun, uint16_t cdb_length,
364 365 uint16_t ext_id);
365 366 void stmf_post_task(scsi_task_t *task, stmf_data_buf_t *dbuf);
366 367 stmf_data_buf_t *stmf_alloc_dbuf(scsi_task_t *task, uint32_t size,
367 368 uint32_t *pminsize, uint32_t flags);
368 369 void stmf_free_dbuf(scsi_task_t *task, stmf_data_buf_t *dbuf);
369 370 stmf_status_t stmf_setup_dbuf(scsi_task_t *task, stmf_data_buf_t *dbuf,
370 371 uint32_t flags);
371 372 void stmf_teardown_dbuf(scsi_task_t *task, stmf_data_buf_t *dbuf);
372 373 stmf_status_t stmf_xfer_data(scsi_task_t *task, stmf_data_buf_t *dbuf,
373 374 uint32_t ioflags);
374 375 stmf_status_t stmf_send_scsi_status(scsi_task_t *task, uint32_t ioflags);
375 376 void stmf_data_xfer_done(scsi_task_t *task, stmf_data_buf_t *dbuf,
376 377 uint32_t iof);
|
↓ open down ↓ |
344 lines elided |
↑ open up ↑ |
377 378 void stmf_send_status_done(scsi_task_t *task, stmf_status_t s, uint32_t iof);
378 379 void stmf_task_lu_done(scsi_task_t *task);
379 380 void stmf_abort(int abort_cmd, scsi_task_t *task, stmf_status_t s, void *arg);
380 381 void stmf_task_lu_aborted(scsi_task_t *task, stmf_status_t s, uint32_t iof);
381 382 void stmf_task_lport_aborted(scsi_task_t *task, stmf_status_t s, uint32_t iof);
382 383 stmf_status_t stmf_task_poll_lu(scsi_task_t *task, uint32_t timeout);
383 384 stmf_status_t stmf_task_poll_lport(scsi_task_t *task, uint32_t timeout);
384 385 stmf_status_t stmf_ctl(int cmd, void *obj, void *arg);
385 386 stmf_status_t stmf_register_itl_handle(struct stmf_lu *lu, uint8_t *lun,
386 387 struct stmf_scsi_session *ss, uint64_t session_id, void *itl_handle);
387 -stmf_status_t stmf_deregister_itl_handle(struct stmf_lu *lu, uint8_t *lun,
388 - struct stmf_scsi_session *ss, uint64_t session_id, void *itl_handle);
389 388 stmf_status_t stmf_deregister_all_lu_itl_handles(struct stmf_lu *lu);
390 389 stmf_status_t stmf_get_itl_handle(struct stmf_lu *lu, uint8_t *lun,
391 390 struct stmf_scsi_session *ss, uint64_t session_id, void **itl_handle_retp);
392 391 stmf_data_buf_t *stmf_handle_to_buf(scsi_task_t *task, uint8_t h);
393 392 stmf_status_t stmf_lu_add_event(struct stmf_lu *lu, int eventid);
394 393 stmf_status_t stmf_lu_remove_event(struct stmf_lu *lu, int eventid);
395 394 stmf_status_t stmf_lport_add_event(struct stmf_local_port *lport, int eventid);
396 395 stmf_status_t stmf_lport_remove_event(struct stmf_local_port *lport,
397 396 int eventid);
398 397 void stmf_wwn_to_devid_desc(struct scsi_devid_desc *sdid, uint8_t *wwn,
399 398 uint8_t protocol_id);
400 399 stmf_status_t stmf_scsilib_uniq_lu_id(uint32_t company_id,
401 400 struct scsi_devid_desc *lu_id);
402 401 stmf_status_t stmf_scsilib_uniq_lu_id2(uint32_t company_id, uint32_t host_id,
403 402 struct scsi_devid_desc *lu_id);
404 403 void stmf_scsilib_send_status(scsi_task_t *task, uint8_t st, uint32_t saa);
405 404 uint32_t stmf_scsilib_prepare_vpd_page83(scsi_task_t *task, uint8_t *page,
406 405 uint32_t page_len, uint8_t byte0, uint32_t vpd_mask);
407 406 uint16_t stmf_scsilib_get_lport_rtid(struct scsi_devid_desc *devid);
408 407 struct scsi_devid_desc *stmf_scsilib_get_devid_desc(uint16_t rtpid);
409 408 void stmf_scsilib_handle_report_tpgs(scsi_task_t *task, stmf_data_buf_t *dbuf);
410 409 void stmf_scsilib_handle_task_mgmt(scsi_task_t *task);
411 410
412 411 struct stmf_remote_port *stmf_scsilib_devid_to_remote_port(
413 412 struct scsi_devid_desc *);
414 413 boolean_t stmf_scsilib_tptid_validate(struct scsi_transport_id *,
415 414 uint32_t, uint16_t *);
416 415 boolean_t stmf_scsilib_tptid_compare(struct scsi_transport_id *,
417 416 struct scsi_transport_id *);
418 417 struct stmf_remote_port *stmf_remote_port_alloc(uint16_t);
419 418 void stmf_remote_port_free(struct stmf_remote_port *);
420 419 #ifdef __cplusplus
421 420 }
422 421 #endif
423 422
424 423 #endif /* _STMF_H */
|
↓ open down ↓ |
26 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX