Print this page
5045 use atomic_{inc,dec}_* instead of atomic_add_*
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/io/comstar/stmf/stmf.c
+++ new/usr/src/uts/common/io/comstar/stmf/stmf.c
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 *
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 23 */
24 24 /*
25 25 * Copyright 2012, Nexenta Systems, Inc. All rights reserved.
26 26 * Copyright (c) 2013 by Delphix. All rights reserved.
27 27 * Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
28 28 */
29 29
30 30 #include <sys/conf.h>
31 31 #include <sys/file.h>
32 32 #include <sys/ddi.h>
33 33 #include <sys/sunddi.h>
34 34 #include <sys/modctl.h>
35 35 #include <sys/scsi/scsi.h>
36 36 #include <sys/scsi/generic/persist.h>
37 37 #include <sys/scsi/impl/scsi_reset_notify.h>
38 38 #include <sys/disp.h>
39 39 #include <sys/byteorder.h>
40 40 #include <sys/atomic.h>
41 41 #include <sys/ethernet.h>
42 42 #include <sys/sdt.h>
43 43 #include <sys/nvpair.h>
44 44 #include <sys/zone.h>
45 45 #include <sys/id_space.h>
46 46
47 47 #include <sys/stmf.h>
48 48 #include <sys/lpif.h>
49 49 #include <sys/portif.h>
50 50 #include <sys/stmf_ioctl.h>
51 51 #include <sys/pppt_ic_if.h>
52 52
53 53 #include "stmf_impl.h"
54 54 #include "lun_map.h"
55 55 #include "stmf_state.h"
56 56 #include "stmf_stats.h"
57 57
58 58 /*
59 59 * Lock order:
60 60 * stmf_state_lock --> ilport_lock/iss_lockp --> ilu_task_lock
61 61 */
62 62
63 63 static uint64_t stmf_session_counter = 0;
64 64 static uint16_t stmf_rtpid_counter = 0;
65 65 /* start messages at 1 */
66 66 static uint64_t stmf_proxy_msg_id = 1;
67 67 #define MSG_ID_TM_BIT 0x8000000000000000
68 68 #define ALIGNED_TO_8BYTE_BOUNDARY(i) (((i) + 7) & ~7)
69 69
70 70 /*
71 71 * When stmf_io_deadman_enabled is set to B_TRUE, we check that finishing up
72 72 * I/O operations on an offlining LU doesn't take longer than stmf_io_deadman
73 73 * seconds. If it does, we trigger a panic to inform the user of hung I/O
74 74 * blocking us for too long.
75 75 */
76 76 boolean_t stmf_io_deadman_enabled = B_TRUE;
77 77 int stmf_io_deadman = 1000; /* seconds */
78 78
79 79 struct stmf_svc_clocks;
80 80
81 81 static int stmf_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
82 82 static int stmf_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
83 83 static int stmf_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg,
84 84 void **result);
85 85 static int stmf_open(dev_t *devp, int flag, int otype, cred_t *credp);
86 86 static int stmf_close(dev_t dev, int flag, int otype, cred_t *credp);
87 87 static int stmf_ioctl(dev_t dev, int cmd, intptr_t data, int mode,
88 88 cred_t *credp, int *rval);
89 89 static int stmf_get_stmf_state(stmf_state_desc_t *std);
90 90 static int stmf_set_stmf_state(stmf_state_desc_t *std);
91 91 static void stmf_abort_task_offline(scsi_task_t *task, int offline_lu,
92 92 char *info);
93 93 static int stmf_set_alua_state(stmf_alua_state_desc_t *alua_state);
94 94 static void stmf_get_alua_state(stmf_alua_state_desc_t *alua_state);
95 95
96 96 static void stmf_task_audit(stmf_i_scsi_task_t *itask,
97 97 task_audit_event_t te, uint32_t cmd_or_iof, stmf_data_buf_t *dbuf);
98 98
99 99 static boolean_t stmf_base16_str_to_binary(char *c, int dplen, uint8_t *dp);
100 100 static char stmf_ctoi(char c);
101 101 stmf_xfer_data_t *stmf_prepare_tpgs_data(uint8_t ilu_alua);
102 102 void stmf_svc_init();
103 103 stmf_status_t stmf_svc_fini();
104 104 void stmf_svc(void *arg);
105 105 static void stmf_wait_ilu_tasks_finish(stmf_i_lu_t *ilu);
106 106 void stmf_svc_queue(int cmd, void *obj, stmf_state_change_info_t *info);
107 107 static void stmf_svc_kill_obj_requests(void *obj);
108 108 static void stmf_svc_timeout(struct stmf_svc_clocks *);
109 109 void stmf_check_freetask();
110 110 void stmf_abort_target_reset(scsi_task_t *task);
111 111 stmf_status_t stmf_lun_reset_poll(stmf_lu_t *lu, struct scsi_task *task,
112 112 int target_reset);
113 113 void stmf_target_reset_poll(struct scsi_task *task);
114 114 void stmf_handle_lun_reset(scsi_task_t *task);
115 115 void stmf_handle_target_reset(scsi_task_t *task);
116 116 void stmf_xd_to_dbuf(stmf_data_buf_t *dbuf, int set_rel_off);
117 117 int stmf_load_ppd_ioctl(stmf_ppioctl_data_t *ppi, uint64_t *ppi_token,
118 118 uint32_t *err_ret);
119 119 int stmf_delete_ppd_ioctl(stmf_ppioctl_data_t *ppi);
120 120 int stmf_get_ppd_ioctl(stmf_ppioctl_data_t *ppi, stmf_ppioctl_data_t *ppi_out,
121 121 uint32_t *err_ret);
122 122 void stmf_delete_ppd(stmf_pp_data_t *ppd);
123 123 void stmf_delete_all_ppds();
124 124 void stmf_trace_clear();
125 125 void stmf_worker_init();
126 126 stmf_status_t stmf_worker_fini();
127 127 void stmf_worker_mgmt();
128 128 void stmf_worker_task(void *arg);
129 129 static void stmf_task_lu_free(scsi_task_t *task, stmf_i_scsi_session_t *iss);
130 130 static stmf_status_t stmf_ic_lu_reg(stmf_ic_reg_dereg_lun_msg_t *msg,
131 131 uint32_t type);
132 132 static stmf_status_t stmf_ic_lu_dereg(stmf_ic_reg_dereg_lun_msg_t *msg);
133 133 static stmf_status_t stmf_ic_rx_scsi_status(stmf_ic_scsi_status_msg_t *msg);
134 134 static stmf_status_t stmf_ic_rx_status(stmf_ic_status_msg_t *msg);
135 135 static stmf_status_t stmf_ic_rx_scsi_data(stmf_ic_scsi_data_msg_t *msg);
136 136 void stmf_task_lu_killall(stmf_lu_t *lu, scsi_task_t *tm_task, stmf_status_t s);
137 137
138 138 /* pppt modhandle */
139 139 ddi_modhandle_t pppt_mod;
140 140
141 141 /* pppt modload imported functions */
142 142 stmf_ic_reg_port_msg_alloc_func_t ic_reg_port_msg_alloc;
143 143 stmf_ic_dereg_port_msg_alloc_func_t ic_dereg_port_msg_alloc;
144 144 stmf_ic_reg_lun_msg_alloc_func_t ic_reg_lun_msg_alloc;
145 145 stmf_ic_dereg_lun_msg_alloc_func_t ic_dereg_lun_msg_alloc;
146 146 stmf_ic_lun_active_msg_alloc_func_t ic_lun_active_msg_alloc;
147 147 stmf_ic_scsi_cmd_msg_alloc_func_t ic_scsi_cmd_msg_alloc;
148 148 stmf_ic_scsi_data_xfer_done_msg_alloc_func_t ic_scsi_data_xfer_done_msg_alloc;
149 149 stmf_ic_session_create_msg_alloc_func_t ic_session_reg_msg_alloc;
150 150 stmf_ic_session_destroy_msg_alloc_func_t ic_session_dereg_msg_alloc;
151 151 stmf_ic_tx_msg_func_t ic_tx_msg;
152 152 stmf_ic_msg_free_func_t ic_msg_free;
153 153
154 154 static void stmf_itl_task_start(stmf_i_scsi_task_t *itask);
155 155 static void stmf_itl_lu_new_task(stmf_i_scsi_task_t *itask);
156 156 static void stmf_itl_task_done(stmf_i_scsi_task_t *itask);
157 157
158 158 static void stmf_lport_xfer_start(stmf_i_scsi_task_t *itask,
159 159 stmf_data_buf_t *dbuf);
160 160 static void stmf_lport_xfer_done(stmf_i_scsi_task_t *itask,
161 161 stmf_data_buf_t *dbuf);
162 162
163 163 static void stmf_update_kstat_lu_q(scsi_task_t *, void());
164 164 static void stmf_update_kstat_lport_q(scsi_task_t *, void());
165 165 static void stmf_update_kstat_lu_io(scsi_task_t *, stmf_data_buf_t *);
166 166 static void stmf_update_kstat_lport_io(scsi_task_t *, stmf_data_buf_t *);
167 167
168 168 static int stmf_irport_compare(const void *void_irport1,
169 169 const void *void_irport2);
170 170 static stmf_i_remote_port_t *stmf_irport_create(scsi_devid_desc_t *rport_devid);
171 171 static void stmf_irport_destroy(stmf_i_remote_port_t *irport);
172 172 static stmf_i_remote_port_t *stmf_irport_register(
173 173 scsi_devid_desc_t *rport_devid);
174 174 static stmf_i_remote_port_t *stmf_irport_lookup_locked(
175 175 scsi_devid_desc_t *rport_devid);
176 176 static void stmf_irport_deregister(stmf_i_remote_port_t *irport);
177 177
178 178 extern struct mod_ops mod_driverops;
179 179
180 180 /* =====[ Tunables ]===== */
181 181 /* Internal tracing */
182 182 volatile int stmf_trace_on = 1;
183 183 volatile int stmf_trace_buf_size = (1 * 1024 * 1024);
184 184 /*
185 185 * The reason default task timeout is 75 is because we want the
186 186 * host to timeout 1st and mostly host timeout is 60 seconds.
187 187 */
188 188 volatile int stmf_default_task_timeout = 75;
189 189 /*
190 190 * Setting this to one means, you are responsible for config load and keeping
191 191 * things in sync with persistent database.
192 192 */
193 193 volatile int stmf_allow_modunload = 0;
194 194
195 195 volatile int stmf_max_nworkers = 256;
196 196 volatile int stmf_min_nworkers = 4;
197 197 volatile int stmf_worker_scale_down_delay = 20;
198 198
199 199 /* === [ Debugging and fault injection ] === */
200 200 #ifdef DEBUG
201 201 volatile int stmf_drop_task_counter = 0;
202 202 volatile int stmf_drop_buf_counter = 0;
203 203
204 204 #endif
205 205
206 206 stmf_state_t stmf_state;
207 207 static stmf_lu_t *dlun0;
208 208
209 209 static uint8_t stmf_first_zero[] =
210 210 { 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 0xff };
211 211 static uint8_t stmf_first_one[] =
212 212 { 0xff, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0 };
213 213
214 214 static kmutex_t trace_buf_lock;
215 215 static int trace_buf_size;
216 216 static int trace_buf_curndx;
217 217 caddr_t stmf_trace_buf;
218 218
219 219 static enum {
220 220 STMF_WORKERS_DISABLED = 0,
221 221 STMF_WORKERS_ENABLING,
222 222 STMF_WORKERS_ENABLED
223 223 } stmf_workers_state = STMF_WORKERS_DISABLED;
224 224 static int stmf_i_max_nworkers;
225 225 static int stmf_i_min_nworkers;
226 226 static int stmf_nworkers_cur; /* # of workers currently running */
227 227 static int stmf_nworkers_needed; /* # of workers need to be running */
228 228 static int stmf_worker_sel_counter = 0;
229 229 static uint32_t stmf_cur_ntasks = 0;
230 230 static clock_t stmf_wm_last = 0;
231 231 /*
232 232 * This is equal to stmf_nworkers_cur while we are increasing # workers and
233 233 * stmf_nworkers_needed while we are decreasing the worker count.
234 234 */
235 235 static int stmf_nworkers_accepting_cmds;
236 236 static stmf_worker_t *stmf_workers = NULL;
237 237 static clock_t stmf_worker_mgmt_delay = 2;
238 238 static clock_t stmf_worker_scale_down_timer = 0;
239 239 static int stmf_worker_scale_down_qd = 0;
240 240
241 241 static struct cb_ops stmf_cb_ops = {
242 242 stmf_open, /* open */
243 243 stmf_close, /* close */
244 244 nodev, /* strategy */
245 245 nodev, /* print */
246 246 nodev, /* dump */
247 247 nodev, /* read */
248 248 nodev, /* write */
249 249 stmf_ioctl, /* ioctl */
250 250 nodev, /* devmap */
251 251 nodev, /* mmap */
252 252 nodev, /* segmap */
253 253 nochpoll, /* chpoll */
254 254 ddi_prop_op, /* cb_prop_op */
255 255 0, /* streamtab */
256 256 D_NEW | D_MP, /* cb_flag */
257 257 CB_REV, /* rev */
258 258 nodev, /* aread */
259 259 nodev /* awrite */
260 260 };
261 261
262 262 static struct dev_ops stmf_ops = {
263 263 DEVO_REV,
264 264 0,
265 265 stmf_getinfo,
266 266 nulldev, /* identify */
267 267 nulldev, /* probe */
268 268 stmf_attach,
269 269 stmf_detach,
270 270 nodev, /* reset */
271 271 &stmf_cb_ops,
272 272 NULL, /* bus_ops */
273 273 NULL /* power */
274 274 };
275 275
276 276 #define STMF_NAME "COMSTAR STMF"
277 277 #define STMF_MODULE_NAME "stmf"
278 278
279 279 static struct modldrv modldrv = {
280 280 &mod_driverops,
281 281 STMF_NAME,
282 282 &stmf_ops
283 283 };
284 284
285 285 static struct modlinkage modlinkage = {
286 286 MODREV_1,
287 287 &modldrv,
288 288 NULL
289 289 };
290 290
291 291 int
292 292 _init(void)
293 293 {
294 294 int ret;
295 295
296 296 ret = mod_install(&modlinkage);
297 297 if (ret)
298 298 return (ret);
299 299 stmf_trace_buf = kmem_zalloc(stmf_trace_buf_size, KM_SLEEP);
300 300 trace_buf_size = stmf_trace_buf_size;
301 301 trace_buf_curndx = 0;
302 302 mutex_init(&trace_buf_lock, NULL, MUTEX_DRIVER, 0);
303 303 bzero(&stmf_state, sizeof (stmf_state_t));
304 304 /* STMF service is off by default */
305 305 stmf_state.stmf_service_running = 0;
306 306 /* default lu/lport states are online */
307 307 stmf_state.stmf_default_lu_state = STMF_STATE_ONLINE;
308 308 stmf_state.stmf_default_lport_state = STMF_STATE_ONLINE;
309 309 mutex_init(&stmf_state.stmf_lock, NULL, MUTEX_DRIVER, NULL);
310 310 cv_init(&stmf_state.stmf_cv, NULL, CV_DRIVER, NULL);
311 311 stmf_session_counter = (uint64_t)ddi_get_lbolt();
312 312 avl_create(&stmf_state.stmf_irportlist,
313 313 stmf_irport_compare, sizeof (stmf_i_remote_port_t),
314 314 offsetof(stmf_i_remote_port_t, irport_ln));
315 315 stmf_state.stmf_ilport_inst_space =
316 316 id_space_create("lport-instances", 0, MAX_ILPORT);
317 317 stmf_state.stmf_irport_inst_space =
318 318 id_space_create("rport-instances", 0, MAX_IRPORT);
319 319 stmf_view_init();
320 320 stmf_svc_init();
321 321 stmf_dlun_init();
322 322 return (ret);
323 323 }
324 324
325 325 int
326 326 _fini(void)
327 327 {
328 328 int ret;
329 329 stmf_i_remote_port_t *irport;
330 330 void *avl_dest_cookie = NULL;
331 331
332 332 if (stmf_state.stmf_service_running)
333 333 return (EBUSY);
334 334 if ((!stmf_allow_modunload) &&
335 335 (stmf_state.stmf_config_state != STMF_CONFIG_NONE)) {
336 336 return (EBUSY);
337 337 }
338 338 if (stmf_state.stmf_nlps || stmf_state.stmf_npps) {
339 339 return (EBUSY);
340 340 }
341 341 if (stmf_dlun_fini() != STMF_SUCCESS)
342 342 return (EBUSY);
343 343 if (stmf_worker_fini() != STMF_SUCCESS) {
344 344 stmf_dlun_init();
345 345 return (EBUSY);
346 346 }
347 347 if (stmf_svc_fini() != STMF_SUCCESS) {
348 348 stmf_dlun_init();
349 349 stmf_worker_init();
350 350 return (EBUSY);
351 351 }
352 352
353 353 ret = mod_remove(&modlinkage);
354 354 if (ret) {
355 355 stmf_svc_init();
356 356 stmf_dlun_init();
357 357 stmf_worker_init();
358 358 return (ret);
359 359 }
360 360
361 361 stmf_view_clear_config();
362 362
363 363 while ((irport = avl_destroy_nodes(&stmf_state.stmf_irportlist,
364 364 &avl_dest_cookie)) != NULL)
365 365 stmf_irport_destroy(irport);
366 366 avl_destroy(&stmf_state.stmf_irportlist);
367 367 id_space_destroy(stmf_state.stmf_ilport_inst_space);
368 368 id_space_destroy(stmf_state.stmf_irport_inst_space);
369 369
370 370 kmem_free(stmf_trace_buf, stmf_trace_buf_size);
371 371 mutex_destroy(&trace_buf_lock);
372 372 mutex_destroy(&stmf_state.stmf_lock);
373 373 cv_destroy(&stmf_state.stmf_cv);
374 374 return (ret);
375 375 }
376 376
377 377 int
378 378 _info(struct modinfo *modinfop)
379 379 {
380 380 return (mod_info(&modlinkage, modinfop));
381 381 }
382 382
383 383 /* ARGSUSED */
384 384 static int
385 385 stmf_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
386 386 {
387 387 switch (cmd) {
388 388 case DDI_INFO_DEVT2DEVINFO:
389 389 *result = stmf_state.stmf_dip;
390 390 break;
391 391 case DDI_INFO_DEVT2INSTANCE:
392 392 *result =
393 393 (void *)(uintptr_t)ddi_get_instance(stmf_state.stmf_dip);
394 394 break;
395 395 default:
396 396 return (DDI_FAILURE);
397 397 }
398 398
399 399 return (DDI_SUCCESS);
400 400 }
401 401
402 402 static int
403 403 stmf_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
404 404 {
405 405 switch (cmd) {
406 406 case DDI_ATTACH:
407 407 stmf_state.stmf_dip = dip;
408 408
409 409 if (ddi_create_minor_node(dip, "admin", S_IFCHR, 0,
410 410 DDI_NT_STMF, 0) != DDI_SUCCESS) {
411 411 break;
412 412 }
413 413 ddi_report_dev(dip);
414 414 return (DDI_SUCCESS);
415 415 }
416 416
417 417 return (DDI_FAILURE);
418 418 }
419 419
420 420 static int
421 421 stmf_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
422 422 {
423 423 switch (cmd) {
424 424 case DDI_DETACH:
425 425 ddi_remove_minor_node(dip, 0);
426 426 return (DDI_SUCCESS);
427 427 }
428 428
429 429 return (DDI_FAILURE);
430 430 }
431 431
432 432 /* ARGSUSED */
433 433 static int
434 434 stmf_open(dev_t *devp, int flag, int otype, cred_t *credp)
435 435 {
436 436 mutex_enter(&stmf_state.stmf_lock);
437 437 if (stmf_state.stmf_exclusive_open) {
438 438 mutex_exit(&stmf_state.stmf_lock);
439 439 return (EBUSY);
440 440 }
441 441 if (flag & FEXCL) {
442 442 if (stmf_state.stmf_opened) {
443 443 mutex_exit(&stmf_state.stmf_lock);
444 444 return (EBUSY);
445 445 }
446 446 stmf_state.stmf_exclusive_open = 1;
447 447 }
448 448 stmf_state.stmf_opened = 1;
449 449 mutex_exit(&stmf_state.stmf_lock);
450 450 return (0);
451 451 }
452 452
453 453 /* ARGSUSED */
454 454 static int
455 455 stmf_close(dev_t dev, int flag, int otype, cred_t *credp)
456 456 {
457 457 mutex_enter(&stmf_state.stmf_lock);
458 458 stmf_state.stmf_opened = 0;
459 459 if (stmf_state.stmf_exclusive_open &&
460 460 (stmf_state.stmf_config_state != STMF_CONFIG_INIT_DONE)) {
461 461 stmf_state.stmf_config_state = STMF_CONFIG_NONE;
462 462 stmf_delete_all_ppds();
463 463 stmf_view_clear_config();
464 464 stmf_view_init();
465 465 }
466 466 stmf_state.stmf_exclusive_open = 0;
467 467 mutex_exit(&stmf_state.stmf_lock);
468 468 return (0);
469 469 }
470 470
471 471 int
472 472 stmf_copyin_iocdata(intptr_t data, int mode, stmf_iocdata_t **iocd,
473 473 void **ibuf, void **obuf)
474 474 {
475 475 int ret;
476 476
477 477 *ibuf = NULL;
478 478 *obuf = NULL;
479 479 *iocd = kmem_zalloc(sizeof (stmf_iocdata_t), KM_SLEEP);
480 480
481 481 ret = ddi_copyin((void *)data, *iocd, sizeof (stmf_iocdata_t), mode);
482 482 if (ret)
483 483 return (EFAULT);
484 484 if ((*iocd)->stmf_version != STMF_VERSION_1) {
485 485 ret = EINVAL;
486 486 goto copyin_iocdata_done;
487 487 }
488 488 if ((*iocd)->stmf_ibuf_size) {
489 489 *ibuf = kmem_zalloc((*iocd)->stmf_ibuf_size, KM_SLEEP);
490 490 ret = ddi_copyin((void *)((unsigned long)(*iocd)->stmf_ibuf),
491 491 *ibuf, (*iocd)->stmf_ibuf_size, mode);
492 492 }
493 493 if ((*iocd)->stmf_obuf_size)
494 494 *obuf = kmem_zalloc((*iocd)->stmf_obuf_size, KM_SLEEP);
495 495
496 496 if (ret == 0)
497 497 return (0);
498 498 ret = EFAULT;
499 499 copyin_iocdata_done:;
500 500 if (*obuf) {
501 501 kmem_free(*obuf, (*iocd)->stmf_obuf_size);
502 502 *obuf = NULL;
503 503 }
504 504 if (*ibuf) {
505 505 kmem_free(*ibuf, (*iocd)->stmf_ibuf_size);
506 506 *ibuf = NULL;
507 507 }
508 508 kmem_free(*iocd, sizeof (stmf_iocdata_t));
509 509 return (ret);
510 510 }
511 511
512 512 int
513 513 stmf_copyout_iocdata(intptr_t data, int mode, stmf_iocdata_t *iocd, void *obuf)
514 514 {
515 515 int ret;
516 516
517 517 if (iocd->stmf_obuf_size) {
518 518 ret = ddi_copyout(obuf, (void *)(unsigned long)iocd->stmf_obuf,
519 519 iocd->stmf_obuf_size, mode);
520 520 if (ret)
521 521 return (EFAULT);
522 522 }
523 523 ret = ddi_copyout(iocd, (void *)data, sizeof (stmf_iocdata_t), mode);
524 524 if (ret)
525 525 return (EFAULT);
526 526 return (0);
527 527 }
528 528
529 529 /* ARGSUSED */
530 530 static int
531 531 stmf_ioctl(dev_t dev, int cmd, intptr_t data, int mode,
532 532 cred_t *credp, int *rval)
533 533 {
534 534 stmf_iocdata_t *iocd;
535 535 void *ibuf = NULL, *obuf = NULL;
536 536 slist_lu_t *luid_list;
537 537 slist_target_port_t *lportid_list;
538 538 stmf_i_lu_t *ilu;
539 539 stmf_i_local_port_t *ilport;
540 540 stmf_i_scsi_session_t *iss;
541 541 slist_scsi_session_t *iss_list;
542 542 sioc_lu_props_t *lup;
543 543 sioc_target_port_props_t *lportp;
544 544 stmf_ppioctl_data_t *ppi, *ppi_out = NULL;
545 545 uint64_t *ppi_token = NULL;
546 546 uint8_t *p_id, *id;
547 547 stmf_state_desc_t *std;
548 548 stmf_status_t ctl_ret;
549 549 stmf_state_change_info_t ssi;
550 550 int ret = 0;
551 551 uint32_t n;
552 552 int i;
553 553 stmf_group_op_data_t *grp_entry;
554 554 stmf_group_name_t *grpname;
555 555 stmf_view_op_entry_t *ve;
556 556 stmf_id_type_t idtype;
557 557 stmf_id_data_t *id_entry;
558 558 stmf_id_list_t *id_list;
559 559 stmf_view_entry_t *view_entry;
560 560 stmf_set_props_t *stmf_set_props;
561 561 uint32_t veid;
562 562 if ((cmd & 0xff000000) != STMF_IOCTL) {
563 563 return (ENOTTY);
564 564 }
565 565
566 566 if (drv_priv(credp) != 0) {
567 567 return (EPERM);
568 568 }
569 569
570 570 ret = stmf_copyin_iocdata(data, mode, &iocd, &ibuf, &obuf);
571 571 if (ret)
572 572 return (ret);
573 573 iocd->stmf_error = 0;
574 574
575 575 switch (cmd) {
576 576 case STMF_IOCTL_LU_LIST:
577 577 /* retrieves both registered/unregistered */
578 578 mutex_enter(&stmf_state.stmf_lock);
579 579 id_list = &stmf_state.stmf_luid_list;
580 580 n = min(id_list->id_count,
581 581 (iocd->stmf_obuf_size)/sizeof (slist_lu_t));
582 582 iocd->stmf_obuf_max_nentries = id_list->id_count;
583 583 luid_list = (slist_lu_t *)obuf;
584 584 id_entry = id_list->idl_head;
585 585 for (i = 0; i < n; i++) {
586 586 bcopy(id_entry->id_data, luid_list[i].lu_guid, 16);
587 587 id_entry = id_entry->id_next;
588 588 }
589 589
590 590 n = iocd->stmf_obuf_size/sizeof (slist_lu_t);
591 591 for (ilu = stmf_state.stmf_ilulist; ilu; ilu = ilu->ilu_next) {
592 592 id = (uint8_t *)ilu->ilu_lu->lu_id;
593 593 if (stmf_lookup_id(id_list, 16, id + 4) == NULL) {
594 594 iocd->stmf_obuf_max_nentries++;
595 595 if (i < n) {
596 596 bcopy(id + 4, luid_list[i].lu_guid,
597 597 sizeof (slist_lu_t));
598 598 i++;
599 599 }
600 600 }
601 601 }
602 602 iocd->stmf_obuf_nentries = i;
603 603 mutex_exit(&stmf_state.stmf_lock);
604 604 break;
605 605
606 606 case STMF_IOCTL_REG_LU_LIST:
607 607 mutex_enter(&stmf_state.stmf_lock);
608 608 iocd->stmf_obuf_max_nentries = stmf_state.stmf_nlus;
609 609 n = min(stmf_state.stmf_nlus,
610 610 (iocd->stmf_obuf_size)/sizeof (slist_lu_t));
611 611 iocd->stmf_obuf_nentries = n;
612 612 ilu = stmf_state.stmf_ilulist;
613 613 luid_list = (slist_lu_t *)obuf;
614 614 for (i = 0; i < n; i++) {
615 615 uint8_t *id;
616 616 id = (uint8_t *)ilu->ilu_lu->lu_id;
617 617 bcopy(id + 4, luid_list[i].lu_guid, 16);
618 618 ilu = ilu->ilu_next;
619 619 }
620 620 mutex_exit(&stmf_state.stmf_lock);
621 621 break;
622 622
623 623 case STMF_IOCTL_VE_LU_LIST:
624 624 mutex_enter(&stmf_state.stmf_lock);
625 625 id_list = &stmf_state.stmf_luid_list;
626 626 n = min(id_list->id_count,
627 627 (iocd->stmf_obuf_size)/sizeof (slist_lu_t));
628 628 iocd->stmf_obuf_max_nentries = id_list->id_count;
629 629 iocd->stmf_obuf_nentries = n;
630 630 luid_list = (slist_lu_t *)obuf;
631 631 id_entry = id_list->idl_head;
632 632 for (i = 0; i < n; i++) {
633 633 bcopy(id_entry->id_data, luid_list[i].lu_guid, 16);
634 634 id_entry = id_entry->id_next;
635 635 }
636 636 mutex_exit(&stmf_state.stmf_lock);
637 637 break;
638 638
639 639 case STMF_IOCTL_TARGET_PORT_LIST:
640 640 mutex_enter(&stmf_state.stmf_lock);
641 641 iocd->stmf_obuf_max_nentries = stmf_state.stmf_nlports;
642 642 n = min(stmf_state.stmf_nlports,
643 643 (iocd->stmf_obuf_size)/sizeof (slist_target_port_t));
644 644 iocd->stmf_obuf_nentries = n;
645 645 ilport = stmf_state.stmf_ilportlist;
646 646 lportid_list = (slist_target_port_t *)obuf;
647 647 for (i = 0; i < n; i++) {
648 648 uint8_t *id;
649 649 id = (uint8_t *)ilport->ilport_lport->lport_id;
650 650 bcopy(id, lportid_list[i].target, id[3] + 4);
651 651 ilport = ilport->ilport_next;
652 652 }
653 653 mutex_exit(&stmf_state.stmf_lock);
654 654 break;
655 655
656 656 case STMF_IOCTL_SESSION_LIST:
657 657 p_id = (uint8_t *)ibuf;
658 658 if ((p_id == NULL) || (iocd->stmf_ibuf_size < 4) ||
659 659 (iocd->stmf_ibuf_size < (p_id[3] + 4))) {
660 660 ret = EINVAL;
661 661 break;
662 662 }
663 663 mutex_enter(&stmf_state.stmf_lock);
664 664 for (ilport = stmf_state.stmf_ilportlist; ilport; ilport =
665 665 ilport->ilport_next) {
666 666 uint8_t *id;
667 667 id = (uint8_t *)ilport->ilport_lport->lport_id;
668 668 if ((p_id[3] == id[3]) &&
669 669 (bcmp(p_id + 4, id + 4, id[3]) == 0)) {
670 670 break;
671 671 }
672 672 }
673 673 if (ilport == NULL) {
674 674 mutex_exit(&stmf_state.stmf_lock);
675 675 ret = ENOENT;
676 676 break;
677 677 }
678 678 iocd->stmf_obuf_max_nentries = ilport->ilport_nsessions;
679 679 n = min(ilport->ilport_nsessions,
680 680 (iocd->stmf_obuf_size)/sizeof (slist_scsi_session_t));
681 681 iocd->stmf_obuf_nentries = n;
682 682 iss = ilport->ilport_ss_list;
683 683 iss_list = (slist_scsi_session_t *)obuf;
684 684 for (i = 0; i < n; i++) {
685 685 uint8_t *id;
686 686 id = (uint8_t *)iss->iss_ss->ss_rport_id;
687 687 bcopy(id, iss_list[i].initiator, id[3] + 4);
688 688 iss_list[i].creation_time = (uint32_t)
689 689 iss->iss_creation_time;
690 690 if (iss->iss_ss->ss_rport_alias) {
691 691 (void) strncpy(iss_list[i].alias,
692 692 iss->iss_ss->ss_rport_alias, 255);
693 693 iss_list[i].alias[255] = 0;
694 694 } else {
695 695 iss_list[i].alias[0] = 0;
696 696 }
697 697 iss = iss->iss_next;
698 698 }
699 699 mutex_exit(&stmf_state.stmf_lock);
700 700 break;
701 701
702 702 case STMF_IOCTL_GET_LU_PROPERTIES:
703 703 p_id = (uint8_t *)ibuf;
704 704 if ((iocd->stmf_ibuf_size < 16) ||
705 705 (iocd->stmf_obuf_size < sizeof (sioc_lu_props_t)) ||
706 706 (p_id[0] == 0)) {
707 707 ret = EINVAL;
708 708 break;
709 709 }
710 710 mutex_enter(&stmf_state.stmf_lock);
711 711 for (ilu = stmf_state.stmf_ilulist; ilu; ilu = ilu->ilu_next) {
712 712 if (bcmp(p_id, ilu->ilu_lu->lu_id->ident, 16) == 0)
713 713 break;
714 714 }
715 715 if (ilu == NULL) {
716 716 mutex_exit(&stmf_state.stmf_lock);
717 717 ret = ENOENT;
718 718 break;
719 719 }
720 720 lup = (sioc_lu_props_t *)obuf;
721 721 bcopy(ilu->ilu_lu->lu_id->ident, lup->lu_guid, 16);
722 722 lup->lu_state = ilu->ilu_state & 0x0f;
723 723 lup->lu_present = 1; /* XXX */
724 724 (void) strncpy(lup->lu_provider_name,
725 725 ilu->ilu_lu->lu_lp->lp_name, 255);
726 726 lup->lu_provider_name[254] = 0;
727 727 if (ilu->ilu_lu->lu_alias) {
728 728 (void) strncpy(lup->lu_alias,
729 729 ilu->ilu_lu->lu_alias, 255);
730 730 lup->lu_alias[255] = 0;
731 731 } else {
732 732 lup->lu_alias[0] = 0;
733 733 }
734 734 mutex_exit(&stmf_state.stmf_lock);
735 735 break;
736 736
737 737 case STMF_IOCTL_GET_TARGET_PORT_PROPERTIES:
738 738 p_id = (uint8_t *)ibuf;
739 739 if ((p_id == NULL) ||
740 740 (iocd->stmf_ibuf_size < (p_id[3] + 4)) ||
741 741 (iocd->stmf_obuf_size <
742 742 sizeof (sioc_target_port_props_t))) {
743 743 ret = EINVAL;
744 744 break;
745 745 }
746 746 mutex_enter(&stmf_state.stmf_lock);
747 747 for (ilport = stmf_state.stmf_ilportlist; ilport;
748 748 ilport = ilport->ilport_next) {
749 749 uint8_t *id;
750 750 id = (uint8_t *)ilport->ilport_lport->lport_id;
751 751 if ((p_id[3] == id[3]) &&
752 752 (bcmp(p_id+4, id+4, id[3]) == 0))
753 753 break;
754 754 }
755 755 if (ilport == NULL) {
756 756 mutex_exit(&stmf_state.stmf_lock);
757 757 ret = ENOENT;
758 758 break;
759 759 }
760 760 lportp = (sioc_target_port_props_t *)obuf;
761 761 bcopy(ilport->ilport_lport->lport_id, lportp->tgt_id,
762 762 ilport->ilport_lport->lport_id->ident_length + 4);
763 763 lportp->tgt_state = ilport->ilport_state & 0x0f;
764 764 lportp->tgt_present = 1; /* XXX */
765 765 (void) strncpy(lportp->tgt_provider_name,
766 766 ilport->ilport_lport->lport_pp->pp_name, 255);
767 767 lportp->tgt_provider_name[254] = 0;
768 768 if (ilport->ilport_lport->lport_alias) {
769 769 (void) strncpy(lportp->tgt_alias,
770 770 ilport->ilport_lport->lport_alias, 255);
771 771 lportp->tgt_alias[255] = 0;
772 772 } else {
773 773 lportp->tgt_alias[0] = 0;
774 774 }
775 775 mutex_exit(&stmf_state.stmf_lock);
776 776 break;
777 777
778 778 case STMF_IOCTL_SET_STMF_STATE:
779 779 if ((ibuf == NULL) ||
780 780 (iocd->stmf_ibuf_size < sizeof (stmf_state_desc_t))) {
781 781 ret = EINVAL;
782 782 break;
783 783 }
784 784 ret = stmf_set_stmf_state((stmf_state_desc_t *)ibuf);
785 785 break;
786 786
787 787 case STMF_IOCTL_GET_STMF_STATE:
788 788 if ((obuf == NULL) ||
789 789 (iocd->stmf_obuf_size < sizeof (stmf_state_desc_t))) {
790 790 ret = EINVAL;
791 791 break;
792 792 }
793 793 ret = stmf_get_stmf_state((stmf_state_desc_t *)obuf);
794 794 break;
795 795
796 796 case STMF_IOCTL_SET_ALUA_STATE:
797 797 if ((ibuf == NULL) ||
798 798 (iocd->stmf_ibuf_size < sizeof (stmf_alua_state_desc_t))) {
799 799 ret = EINVAL;
800 800 break;
801 801 }
802 802 ret = stmf_set_alua_state((stmf_alua_state_desc_t *)ibuf);
803 803 break;
804 804
805 805 case STMF_IOCTL_GET_ALUA_STATE:
806 806 if ((obuf == NULL) ||
807 807 (iocd->stmf_obuf_size < sizeof (stmf_alua_state_desc_t))) {
808 808 ret = EINVAL;
809 809 break;
810 810 }
811 811 stmf_get_alua_state((stmf_alua_state_desc_t *)obuf);
812 812 break;
813 813
814 814 case STMF_IOCTL_SET_LU_STATE:
815 815 ssi.st_rflags = STMF_RFLAG_USER_REQUEST;
816 816 ssi.st_additional_info = NULL;
817 817 std = (stmf_state_desc_t *)ibuf;
818 818 if ((ibuf == NULL) ||
819 819 (iocd->stmf_ibuf_size < sizeof (stmf_state_desc_t))) {
820 820 ret = EINVAL;
821 821 break;
822 822 }
823 823 p_id = std->ident;
824 824 mutex_enter(&stmf_state.stmf_lock);
825 825 if (stmf_state.stmf_inventory_locked) {
826 826 mutex_exit(&stmf_state.stmf_lock);
827 827 ret = EBUSY;
828 828 break;
829 829 }
830 830 for (ilu = stmf_state.stmf_ilulist; ilu; ilu = ilu->ilu_next) {
831 831 if (bcmp(p_id, ilu->ilu_lu->lu_id->ident, 16) == 0)
832 832 break;
833 833 }
834 834 if (ilu == NULL) {
835 835 mutex_exit(&stmf_state.stmf_lock);
836 836 ret = ENOENT;
837 837 break;
838 838 }
839 839 stmf_state.stmf_inventory_locked = 1;
840 840 mutex_exit(&stmf_state.stmf_lock);
841 841 cmd = (std->state == STMF_STATE_ONLINE) ? STMF_CMD_LU_ONLINE :
842 842 STMF_CMD_LU_OFFLINE;
843 843 ctl_ret = stmf_ctl(cmd, (void *)ilu->ilu_lu, &ssi);
844 844 if (ctl_ret == STMF_ALREADY)
845 845 ret = 0;
846 846 else if (ctl_ret == STMF_BUSY)
847 847 ret = EBUSY;
848 848 else if (ctl_ret != STMF_SUCCESS)
849 849 ret = EIO;
850 850 mutex_enter(&stmf_state.stmf_lock);
851 851 stmf_state.stmf_inventory_locked = 0;
852 852 mutex_exit(&stmf_state.stmf_lock);
853 853 break;
854 854
855 855 case STMF_IOCTL_SET_STMF_PROPS:
856 856 if ((ibuf == NULL) ||
857 857 (iocd->stmf_ibuf_size < sizeof (stmf_set_props_t))) {
858 858 ret = EINVAL;
859 859 break;
860 860 }
861 861 stmf_set_props = (stmf_set_props_t *)ibuf;
862 862 mutex_enter(&stmf_state.stmf_lock);
863 863 if ((stmf_set_props->default_lu_state_value ==
864 864 STMF_STATE_OFFLINE) ||
865 865 (stmf_set_props->default_lu_state_value ==
866 866 STMF_STATE_ONLINE)) {
867 867 stmf_state.stmf_default_lu_state =
868 868 stmf_set_props->default_lu_state_value;
869 869 }
870 870 if ((stmf_set_props->default_target_state_value ==
871 871 STMF_STATE_OFFLINE) ||
872 872 (stmf_set_props->default_target_state_value ==
873 873 STMF_STATE_ONLINE)) {
874 874 stmf_state.stmf_default_lport_state =
875 875 stmf_set_props->default_target_state_value;
876 876 }
877 877
878 878 mutex_exit(&stmf_state.stmf_lock);
879 879 break;
880 880
881 881 case STMF_IOCTL_SET_TARGET_PORT_STATE:
882 882 ssi.st_rflags = STMF_RFLAG_USER_REQUEST;
883 883 ssi.st_additional_info = NULL;
884 884 std = (stmf_state_desc_t *)ibuf;
885 885 if ((ibuf == NULL) ||
886 886 (iocd->stmf_ibuf_size < sizeof (stmf_state_desc_t))) {
887 887 ret = EINVAL;
888 888 break;
889 889 }
890 890 p_id = std->ident;
891 891 mutex_enter(&stmf_state.stmf_lock);
892 892 if (stmf_state.stmf_inventory_locked) {
893 893 mutex_exit(&stmf_state.stmf_lock);
894 894 ret = EBUSY;
895 895 break;
896 896 }
897 897 for (ilport = stmf_state.stmf_ilportlist; ilport;
898 898 ilport = ilport->ilport_next) {
899 899 uint8_t *id;
900 900 id = (uint8_t *)ilport->ilport_lport->lport_id;
901 901 if ((id[3] == p_id[3]) &&
902 902 (bcmp(id+4, p_id+4, id[3]) == 0)) {
903 903 break;
904 904 }
905 905 }
906 906 if (ilport == NULL) {
907 907 mutex_exit(&stmf_state.stmf_lock);
908 908 ret = ENOENT;
909 909 break;
910 910 }
911 911 stmf_state.stmf_inventory_locked = 1;
912 912 mutex_exit(&stmf_state.stmf_lock);
913 913 cmd = (std->state == STMF_STATE_ONLINE) ?
914 914 STMF_CMD_LPORT_ONLINE : STMF_CMD_LPORT_OFFLINE;
915 915 ctl_ret = stmf_ctl(cmd, (void *)ilport->ilport_lport, &ssi);
916 916 if (ctl_ret == STMF_ALREADY)
917 917 ret = 0;
918 918 else if (ctl_ret == STMF_BUSY)
919 919 ret = EBUSY;
920 920 else if (ctl_ret != STMF_SUCCESS)
921 921 ret = EIO;
922 922 mutex_enter(&stmf_state.stmf_lock);
923 923 stmf_state.stmf_inventory_locked = 0;
924 924 mutex_exit(&stmf_state.stmf_lock);
925 925 break;
926 926
927 927 case STMF_IOCTL_ADD_HG_ENTRY:
928 928 idtype = STMF_ID_TYPE_HOST;
929 929 /* FALLTHROUGH */
930 930 case STMF_IOCTL_ADD_TG_ENTRY:
931 931 if (stmf_state.stmf_config_state == STMF_CONFIG_NONE) {
932 932 ret = EACCES;
933 933 iocd->stmf_error = STMF_IOCERR_UPDATE_NEED_CFG_INIT;
934 934 break;
935 935 }
936 936 if (cmd == STMF_IOCTL_ADD_TG_ENTRY) {
937 937 idtype = STMF_ID_TYPE_TARGET;
938 938 }
939 939 grp_entry = (stmf_group_op_data_t *)ibuf;
940 940 if ((ibuf == NULL) ||
941 941 (iocd->stmf_ibuf_size < sizeof (stmf_group_op_data_t))) {
942 942 ret = EINVAL;
943 943 break;
944 944 }
945 945 if (grp_entry->group.name[0] == '*') {
946 946 ret = EINVAL;
947 947 break; /* not allowed */
948 948 }
949 949 mutex_enter(&stmf_state.stmf_lock);
950 950 ret = stmf_add_group_member(grp_entry->group.name,
951 951 grp_entry->group.name_size,
952 952 grp_entry->ident + 4,
953 953 grp_entry->ident[3],
954 954 idtype,
955 955 &iocd->stmf_error);
956 956 mutex_exit(&stmf_state.stmf_lock);
957 957 break;
958 958 case STMF_IOCTL_REMOVE_HG_ENTRY:
959 959 idtype = STMF_ID_TYPE_HOST;
960 960 /* FALLTHROUGH */
961 961 case STMF_IOCTL_REMOVE_TG_ENTRY:
962 962 if (stmf_state.stmf_config_state == STMF_CONFIG_NONE) {
963 963 ret = EACCES;
964 964 iocd->stmf_error = STMF_IOCERR_UPDATE_NEED_CFG_INIT;
965 965 break;
966 966 }
967 967 if (cmd == STMF_IOCTL_REMOVE_TG_ENTRY) {
968 968 idtype = STMF_ID_TYPE_TARGET;
969 969 }
970 970 grp_entry = (stmf_group_op_data_t *)ibuf;
971 971 if ((ibuf == NULL) ||
972 972 (iocd->stmf_ibuf_size < sizeof (stmf_group_op_data_t))) {
973 973 ret = EINVAL;
974 974 break;
975 975 }
976 976 if (grp_entry->group.name[0] == '*') {
977 977 ret = EINVAL;
978 978 break; /* not allowed */
979 979 }
980 980 mutex_enter(&stmf_state.stmf_lock);
981 981 ret = stmf_remove_group_member(grp_entry->group.name,
982 982 grp_entry->group.name_size,
983 983 grp_entry->ident + 4,
984 984 grp_entry->ident[3],
985 985 idtype,
986 986 &iocd->stmf_error);
987 987 mutex_exit(&stmf_state.stmf_lock);
988 988 break;
989 989 case STMF_IOCTL_CREATE_HOST_GROUP:
990 990 idtype = STMF_ID_TYPE_HOST_GROUP;
991 991 /* FALLTHROUGH */
992 992 case STMF_IOCTL_CREATE_TARGET_GROUP:
993 993 if (stmf_state.stmf_config_state == STMF_CONFIG_NONE) {
994 994 ret = EACCES;
995 995 iocd->stmf_error = STMF_IOCERR_UPDATE_NEED_CFG_INIT;
996 996 break;
997 997 }
998 998 grpname = (stmf_group_name_t *)ibuf;
999 999
1000 1000 if (cmd == STMF_IOCTL_CREATE_TARGET_GROUP)
1001 1001 idtype = STMF_ID_TYPE_TARGET_GROUP;
1002 1002 if ((ibuf == NULL) ||
1003 1003 (iocd->stmf_ibuf_size < sizeof (stmf_group_name_t))) {
1004 1004 ret = EINVAL;
1005 1005 break;
1006 1006 }
1007 1007 if (grpname->name[0] == '*') {
1008 1008 ret = EINVAL;
1009 1009 break; /* not allowed */
1010 1010 }
1011 1011 mutex_enter(&stmf_state.stmf_lock);
1012 1012 ret = stmf_add_group(grpname->name,
1013 1013 grpname->name_size, idtype, &iocd->stmf_error);
1014 1014 mutex_exit(&stmf_state.stmf_lock);
1015 1015 break;
1016 1016 case STMF_IOCTL_REMOVE_HOST_GROUP:
1017 1017 idtype = STMF_ID_TYPE_HOST_GROUP;
1018 1018 /* FALLTHROUGH */
1019 1019 case STMF_IOCTL_REMOVE_TARGET_GROUP:
1020 1020 if (stmf_state.stmf_config_state == STMF_CONFIG_NONE) {
1021 1021 ret = EACCES;
1022 1022 iocd->stmf_error = STMF_IOCERR_UPDATE_NEED_CFG_INIT;
1023 1023 break;
1024 1024 }
1025 1025 grpname = (stmf_group_name_t *)ibuf;
1026 1026 if (cmd == STMF_IOCTL_REMOVE_TARGET_GROUP)
1027 1027 idtype = STMF_ID_TYPE_TARGET_GROUP;
1028 1028 if ((ibuf == NULL) ||
1029 1029 (iocd->stmf_ibuf_size < sizeof (stmf_group_name_t))) {
1030 1030 ret = EINVAL;
1031 1031 break;
1032 1032 }
1033 1033 if (grpname->name[0] == '*') {
1034 1034 ret = EINVAL;
1035 1035 break; /* not allowed */
1036 1036 }
1037 1037 mutex_enter(&stmf_state.stmf_lock);
1038 1038 ret = stmf_remove_group(grpname->name,
1039 1039 grpname->name_size, idtype, &iocd->stmf_error);
1040 1040 mutex_exit(&stmf_state.stmf_lock);
1041 1041 break;
1042 1042 case STMF_IOCTL_VALIDATE_VIEW:
1043 1043 case STMF_IOCTL_ADD_VIEW_ENTRY:
1044 1044 if (stmf_state.stmf_config_state == STMF_CONFIG_NONE) {
1045 1045 ret = EACCES;
1046 1046 iocd->stmf_error = STMF_IOCERR_UPDATE_NEED_CFG_INIT;
1047 1047 break;
1048 1048 }
1049 1049 ve = (stmf_view_op_entry_t *)ibuf;
1050 1050 if ((ibuf == NULL) ||
1051 1051 (iocd->stmf_ibuf_size < sizeof (stmf_view_op_entry_t))) {
1052 1052 ret = EINVAL;
1053 1053 break;
1054 1054 }
1055 1055 if (!ve->ve_lu_number_valid)
1056 1056 ve->ve_lu_nbr[2] = 0xFF;
1057 1057 if (ve->ve_all_hosts) {
1058 1058 ve->ve_host_group.name[0] = '*';
1059 1059 ve->ve_host_group.name_size = 1;
1060 1060 }
1061 1061 if (ve->ve_all_targets) {
1062 1062 ve->ve_target_group.name[0] = '*';
1063 1063 ve->ve_target_group.name_size = 1;
1064 1064 }
1065 1065 if (ve->ve_ndx_valid)
1066 1066 veid = ve->ve_ndx;
1067 1067 else
1068 1068 veid = 0xffffffff;
1069 1069 mutex_enter(&stmf_state.stmf_lock);
1070 1070 if (cmd == STMF_IOCTL_ADD_VIEW_ENTRY) {
1071 1071 ret = stmf_add_ve(ve->ve_host_group.name,
1072 1072 ve->ve_host_group.name_size,
1073 1073 ve->ve_target_group.name,
1074 1074 ve->ve_target_group.name_size,
1075 1075 ve->ve_guid,
1076 1076 &veid,
1077 1077 ve->ve_lu_nbr,
1078 1078 &iocd->stmf_error);
1079 1079 } else { /* STMF_IOCTL_VALIDATE_VIEW */
1080 1080 ret = stmf_validate_lun_ve(ve->ve_host_group.name,
1081 1081 ve->ve_host_group.name_size,
1082 1082 ve->ve_target_group.name,
1083 1083 ve->ve_target_group.name_size,
1084 1084 ve->ve_lu_nbr,
1085 1085 &iocd->stmf_error);
1086 1086 }
1087 1087 mutex_exit(&stmf_state.stmf_lock);
1088 1088 if (ret == 0 &&
1089 1089 (!ve->ve_ndx_valid || !ve->ve_lu_number_valid) &&
1090 1090 iocd->stmf_obuf_size >= sizeof (stmf_view_op_entry_t)) {
1091 1091 stmf_view_op_entry_t *ve_ret =
1092 1092 (stmf_view_op_entry_t *)obuf;
1093 1093 iocd->stmf_obuf_nentries = 1;
1094 1094 iocd->stmf_obuf_max_nentries = 1;
1095 1095 if (!ve->ve_ndx_valid) {
1096 1096 ve_ret->ve_ndx = veid;
1097 1097 ve_ret->ve_ndx_valid = 1;
1098 1098 }
1099 1099 if (!ve->ve_lu_number_valid) {
1100 1100 ve_ret->ve_lu_number_valid = 1;
1101 1101 bcopy(ve->ve_lu_nbr, ve_ret->ve_lu_nbr, 8);
1102 1102 }
1103 1103 }
1104 1104 break;
1105 1105 case STMF_IOCTL_REMOVE_VIEW_ENTRY:
1106 1106 if (stmf_state.stmf_config_state == STMF_CONFIG_NONE) {
1107 1107 ret = EACCES;
1108 1108 iocd->stmf_error = STMF_IOCERR_UPDATE_NEED_CFG_INIT;
1109 1109 break;
1110 1110 }
1111 1111 ve = (stmf_view_op_entry_t *)ibuf;
1112 1112 if ((ibuf == NULL) ||
1113 1113 (iocd->stmf_ibuf_size < sizeof (stmf_view_op_entry_t))) {
1114 1114 ret = EINVAL;
1115 1115 break;
1116 1116 }
1117 1117 if (!ve->ve_ndx_valid) {
1118 1118 ret = EINVAL;
1119 1119 break;
1120 1120 }
1121 1121 mutex_enter(&stmf_state.stmf_lock);
1122 1122 ret = stmf_remove_ve_by_id(ve->ve_guid, ve->ve_ndx,
1123 1123 &iocd->stmf_error);
1124 1124 mutex_exit(&stmf_state.stmf_lock);
1125 1125 break;
1126 1126 case STMF_IOCTL_GET_HG_LIST:
1127 1127 id_list = &stmf_state.stmf_hg_list;
1128 1128 /* FALLTHROUGH */
1129 1129 case STMF_IOCTL_GET_TG_LIST:
1130 1130 if (cmd == STMF_IOCTL_GET_TG_LIST)
1131 1131 id_list = &stmf_state.stmf_tg_list;
1132 1132 mutex_enter(&stmf_state.stmf_lock);
1133 1133 iocd->stmf_obuf_max_nentries = id_list->id_count;
1134 1134 n = min(id_list->id_count,
1135 1135 (iocd->stmf_obuf_size)/sizeof (stmf_group_name_t));
1136 1136 iocd->stmf_obuf_nentries = n;
1137 1137 id_entry = id_list->idl_head;
1138 1138 grpname = (stmf_group_name_t *)obuf;
1139 1139 for (i = 0; i < n; i++) {
1140 1140 if (id_entry->id_data[0] == '*') {
1141 1141 if (iocd->stmf_obuf_nentries > 0) {
1142 1142 iocd->stmf_obuf_nentries--;
1143 1143 }
1144 1144 id_entry = id_entry->id_next;
1145 1145 continue;
1146 1146 }
1147 1147 grpname->name_size = id_entry->id_data_size;
1148 1148 bcopy(id_entry->id_data, grpname->name,
1149 1149 id_entry->id_data_size);
1150 1150 grpname++;
1151 1151 id_entry = id_entry->id_next;
1152 1152 }
1153 1153 mutex_exit(&stmf_state.stmf_lock);
1154 1154 break;
1155 1155 case STMF_IOCTL_GET_HG_ENTRIES:
1156 1156 id_list = &stmf_state.stmf_hg_list;
1157 1157 /* FALLTHROUGH */
1158 1158 case STMF_IOCTL_GET_TG_ENTRIES:
1159 1159 grpname = (stmf_group_name_t *)ibuf;
1160 1160 if ((ibuf == NULL) ||
1161 1161 (iocd->stmf_ibuf_size < sizeof (stmf_group_name_t))) {
1162 1162 ret = EINVAL;
1163 1163 break;
1164 1164 }
1165 1165 if (cmd == STMF_IOCTL_GET_TG_ENTRIES) {
1166 1166 id_list = &stmf_state.stmf_tg_list;
1167 1167 }
1168 1168 mutex_enter(&stmf_state.stmf_lock);
1169 1169 id_entry = stmf_lookup_id(id_list, grpname->name_size,
1170 1170 grpname->name);
1171 1171 if (!id_entry)
1172 1172 ret = ENODEV;
1173 1173 else {
1174 1174 stmf_ge_ident_t *grp_entry;
1175 1175 id_list = (stmf_id_list_t *)id_entry->id_impl_specific;
1176 1176 iocd->stmf_obuf_max_nentries = id_list->id_count;
1177 1177 n = min(id_list->id_count,
1178 1178 iocd->stmf_obuf_size/sizeof (stmf_ge_ident_t));
1179 1179 iocd->stmf_obuf_nentries = n;
1180 1180 id_entry = id_list->idl_head;
1181 1181 grp_entry = (stmf_ge_ident_t *)obuf;
1182 1182 for (i = 0; i < n; i++) {
1183 1183 bcopy(id_entry->id_data, grp_entry->ident,
1184 1184 id_entry->id_data_size);
1185 1185 grp_entry->ident_size = id_entry->id_data_size;
1186 1186 id_entry = id_entry->id_next;
1187 1187 grp_entry++;
1188 1188 }
1189 1189 }
1190 1190 mutex_exit(&stmf_state.stmf_lock);
1191 1191 break;
1192 1192
1193 1193 case STMF_IOCTL_GET_VE_LIST:
1194 1194 n = iocd->stmf_obuf_size/sizeof (stmf_view_op_entry_t);
1195 1195 mutex_enter(&stmf_state.stmf_lock);
1196 1196 ve = (stmf_view_op_entry_t *)obuf;
1197 1197 for (id_entry = stmf_state.stmf_luid_list.idl_head;
1198 1198 id_entry; id_entry = id_entry->id_next) {
1199 1199 for (view_entry = (stmf_view_entry_t *)
1200 1200 id_entry->id_impl_specific; view_entry;
1201 1201 view_entry = view_entry->ve_next) {
1202 1202 iocd->stmf_obuf_max_nentries++;
1203 1203 if (iocd->stmf_obuf_nentries >= n)
1204 1204 continue;
1205 1205 ve->ve_ndx_valid = 1;
1206 1206 ve->ve_ndx = view_entry->ve_id;
1207 1207 ve->ve_lu_number_valid = 1;
1208 1208 bcopy(view_entry->ve_lun, ve->ve_lu_nbr, 8);
1209 1209 bcopy(view_entry->ve_luid->id_data, ve->ve_guid,
1210 1210 view_entry->ve_luid->id_data_size);
1211 1211 if (view_entry->ve_hg->id_data[0] == '*') {
1212 1212 ve->ve_all_hosts = 1;
1213 1213 } else {
1214 1214 bcopy(view_entry->ve_hg->id_data,
1215 1215 ve->ve_host_group.name,
1216 1216 view_entry->ve_hg->id_data_size);
1217 1217 ve->ve_host_group.name_size =
1218 1218 view_entry->ve_hg->id_data_size;
1219 1219 }
1220 1220
1221 1221 if (view_entry->ve_tg->id_data[0] == '*') {
1222 1222 ve->ve_all_targets = 1;
1223 1223 } else {
1224 1224 bcopy(view_entry->ve_tg->id_data,
1225 1225 ve->ve_target_group.name,
1226 1226 view_entry->ve_tg->id_data_size);
1227 1227 ve->ve_target_group.name_size =
1228 1228 view_entry->ve_tg->id_data_size;
1229 1229 }
1230 1230 ve++;
1231 1231 iocd->stmf_obuf_nentries++;
1232 1232 }
1233 1233 }
1234 1234 mutex_exit(&stmf_state.stmf_lock);
1235 1235 break;
1236 1236
1237 1237 case STMF_IOCTL_LU_VE_LIST:
1238 1238 p_id = (uint8_t *)ibuf;
1239 1239 if ((iocd->stmf_ibuf_size != 16) ||
1240 1240 (iocd->stmf_obuf_size < sizeof (stmf_view_op_entry_t))) {
1241 1241 ret = EINVAL;
1242 1242 break;
1243 1243 }
1244 1244
1245 1245 n = iocd->stmf_obuf_size/sizeof (stmf_view_op_entry_t);
1246 1246 mutex_enter(&stmf_state.stmf_lock);
1247 1247 ve = (stmf_view_op_entry_t *)obuf;
1248 1248 for (id_entry = stmf_state.stmf_luid_list.idl_head;
1249 1249 id_entry; id_entry = id_entry->id_next) {
1250 1250 if (bcmp(id_entry->id_data, p_id, 16) != 0)
1251 1251 continue;
1252 1252 for (view_entry = (stmf_view_entry_t *)
1253 1253 id_entry->id_impl_specific; view_entry;
1254 1254 view_entry = view_entry->ve_next) {
1255 1255 iocd->stmf_obuf_max_nentries++;
1256 1256 if (iocd->stmf_obuf_nentries >= n)
1257 1257 continue;
1258 1258 ve->ve_ndx_valid = 1;
1259 1259 ve->ve_ndx = view_entry->ve_id;
1260 1260 ve->ve_lu_number_valid = 1;
1261 1261 bcopy(view_entry->ve_lun, ve->ve_lu_nbr, 8);
1262 1262 bcopy(view_entry->ve_luid->id_data, ve->ve_guid,
1263 1263 view_entry->ve_luid->id_data_size);
1264 1264 if (view_entry->ve_hg->id_data[0] == '*') {
1265 1265 ve->ve_all_hosts = 1;
1266 1266 } else {
1267 1267 bcopy(view_entry->ve_hg->id_data,
1268 1268 ve->ve_host_group.name,
1269 1269 view_entry->ve_hg->id_data_size);
1270 1270 ve->ve_host_group.name_size =
1271 1271 view_entry->ve_hg->id_data_size;
1272 1272 }
1273 1273
1274 1274 if (view_entry->ve_tg->id_data[0] == '*') {
1275 1275 ve->ve_all_targets = 1;
1276 1276 } else {
1277 1277 bcopy(view_entry->ve_tg->id_data,
1278 1278 ve->ve_target_group.name,
1279 1279 view_entry->ve_tg->id_data_size);
1280 1280 ve->ve_target_group.name_size =
1281 1281 view_entry->ve_tg->id_data_size;
1282 1282 }
1283 1283 ve++;
1284 1284 iocd->stmf_obuf_nentries++;
1285 1285 }
1286 1286 break;
1287 1287 }
1288 1288 mutex_exit(&stmf_state.stmf_lock);
1289 1289 break;
1290 1290
1291 1291 case STMF_IOCTL_LOAD_PP_DATA:
1292 1292 if (stmf_state.stmf_config_state == STMF_CONFIG_NONE) {
1293 1293 ret = EACCES;
1294 1294 iocd->stmf_error = STMF_IOCERR_UPDATE_NEED_CFG_INIT;
1295 1295 break;
1296 1296 }
1297 1297 ppi = (stmf_ppioctl_data_t *)ibuf;
1298 1298 if ((ppi == NULL) ||
1299 1299 (iocd->stmf_ibuf_size < sizeof (stmf_ppioctl_data_t))) {
1300 1300 ret = EINVAL;
1301 1301 break;
1302 1302 }
1303 1303 /* returned token */
1304 1304 ppi_token = (uint64_t *)obuf;
1305 1305 if ((ppi_token == NULL) ||
1306 1306 (iocd->stmf_obuf_size < sizeof (uint64_t))) {
1307 1307 ret = EINVAL;
1308 1308 break;
1309 1309 }
1310 1310 ret = stmf_load_ppd_ioctl(ppi, ppi_token, &iocd->stmf_error);
1311 1311 break;
1312 1312
1313 1313 case STMF_IOCTL_GET_PP_DATA:
1314 1314 if (stmf_state.stmf_config_state == STMF_CONFIG_NONE) {
1315 1315 ret = EACCES;
1316 1316 iocd->stmf_error = STMF_IOCERR_UPDATE_NEED_CFG_INIT;
1317 1317 break;
1318 1318 }
1319 1319 ppi = (stmf_ppioctl_data_t *)ibuf;
1320 1320 if (ppi == NULL ||
1321 1321 (iocd->stmf_ibuf_size < sizeof (stmf_ppioctl_data_t))) {
1322 1322 ret = EINVAL;
1323 1323 break;
1324 1324 }
1325 1325 ppi_out = (stmf_ppioctl_data_t *)obuf;
1326 1326 if ((ppi_out == NULL) ||
1327 1327 (iocd->stmf_obuf_size < sizeof (stmf_ppioctl_data_t))) {
1328 1328 ret = EINVAL;
1329 1329 break;
1330 1330 }
1331 1331 ret = stmf_get_ppd_ioctl(ppi, ppi_out, &iocd->stmf_error);
1332 1332 break;
1333 1333
1334 1334 case STMF_IOCTL_CLEAR_PP_DATA:
1335 1335 if (stmf_state.stmf_config_state == STMF_CONFIG_NONE) {
1336 1336 ret = EACCES;
1337 1337 iocd->stmf_error = STMF_IOCERR_UPDATE_NEED_CFG_INIT;
1338 1338 break;
1339 1339 }
1340 1340 ppi = (stmf_ppioctl_data_t *)ibuf;
1341 1341 if ((ppi == NULL) ||
1342 1342 (iocd->stmf_ibuf_size < sizeof (stmf_ppioctl_data_t))) {
1343 1343 ret = EINVAL;
1344 1344 break;
1345 1345 }
1346 1346 ret = stmf_delete_ppd_ioctl(ppi);
1347 1347 break;
1348 1348
1349 1349 case STMF_IOCTL_CLEAR_TRACE:
1350 1350 stmf_trace_clear();
1351 1351 break;
1352 1352
1353 1353 case STMF_IOCTL_ADD_TRACE:
1354 1354 if (iocd->stmf_ibuf_size && ibuf) {
1355 1355 ((uint8_t *)ibuf)[iocd->stmf_ibuf_size - 1] = 0;
1356 1356 stmf_trace("\nstradm", "%s\n", ibuf);
1357 1357 }
1358 1358 break;
1359 1359
1360 1360 case STMF_IOCTL_GET_TRACE_POSITION:
1361 1361 if (obuf && (iocd->stmf_obuf_size > 3)) {
1362 1362 mutex_enter(&trace_buf_lock);
1363 1363 *((int *)obuf) = trace_buf_curndx;
1364 1364 mutex_exit(&trace_buf_lock);
1365 1365 } else {
1366 1366 ret = EINVAL;
1367 1367 }
1368 1368 break;
1369 1369
1370 1370 case STMF_IOCTL_GET_TRACE:
1371 1371 if ((iocd->stmf_obuf_size == 0) || (iocd->stmf_ibuf_size < 4)) {
1372 1372 ret = EINVAL;
1373 1373 break;
1374 1374 }
1375 1375 i = *((int *)ibuf);
1376 1376 if ((i > trace_buf_size) || ((i + iocd->stmf_obuf_size) >
1377 1377 trace_buf_size)) {
1378 1378 ret = EINVAL;
1379 1379 break;
1380 1380 }
1381 1381 mutex_enter(&trace_buf_lock);
1382 1382 bcopy(stmf_trace_buf + i, obuf, iocd->stmf_obuf_size);
1383 1383 mutex_exit(&trace_buf_lock);
1384 1384 break;
1385 1385
1386 1386 default:
1387 1387 ret = ENOTTY;
1388 1388 }
1389 1389
1390 1390 if (ret == 0) {
1391 1391 ret = stmf_copyout_iocdata(data, mode, iocd, obuf);
1392 1392 } else if (iocd->stmf_error) {
1393 1393 (void) stmf_copyout_iocdata(data, mode, iocd, obuf);
1394 1394 }
1395 1395 if (obuf) {
1396 1396 kmem_free(obuf, iocd->stmf_obuf_size);
1397 1397 obuf = NULL;
1398 1398 }
1399 1399 if (ibuf) {
1400 1400 kmem_free(ibuf, iocd->stmf_ibuf_size);
1401 1401 ibuf = NULL;
1402 1402 }
1403 1403 kmem_free(iocd, sizeof (stmf_iocdata_t));
1404 1404 return (ret);
1405 1405 }
1406 1406
1407 1407 static int
1408 1408 stmf_get_service_state()
1409 1409 {
1410 1410 stmf_i_local_port_t *ilport;
1411 1411 stmf_i_lu_t *ilu;
1412 1412 int online = 0;
1413 1413 int offline = 0;
1414 1414 int onlining = 0;
1415 1415 int offlining = 0;
1416 1416
1417 1417 ASSERT(mutex_owned(&stmf_state.stmf_lock));
1418 1418 for (ilport = stmf_state.stmf_ilportlist; ilport != NULL;
1419 1419 ilport = ilport->ilport_next) {
1420 1420 if (ilport->ilport_state == STMF_STATE_OFFLINE)
1421 1421 offline++;
1422 1422 else if (ilport->ilport_state == STMF_STATE_ONLINE)
1423 1423 online++;
1424 1424 else if (ilport->ilport_state == STMF_STATE_ONLINING)
1425 1425 onlining++;
1426 1426 else if (ilport->ilport_state == STMF_STATE_OFFLINING)
1427 1427 offlining++;
1428 1428 }
1429 1429
1430 1430 for (ilu = stmf_state.stmf_ilulist; ilu != NULL;
1431 1431 ilu = ilu->ilu_next) {
1432 1432 if (ilu->ilu_state == STMF_STATE_OFFLINE)
1433 1433 offline++;
1434 1434 else if (ilu->ilu_state == STMF_STATE_ONLINE)
1435 1435 online++;
1436 1436 else if (ilu->ilu_state == STMF_STATE_ONLINING)
1437 1437 onlining++;
1438 1438 else if (ilu->ilu_state == STMF_STATE_OFFLINING)
1439 1439 offlining++;
1440 1440 }
1441 1441
1442 1442 if (stmf_state.stmf_service_running) {
1443 1443 if (onlining)
1444 1444 return (STMF_STATE_ONLINING);
1445 1445 else
1446 1446 return (STMF_STATE_ONLINE);
1447 1447 }
1448 1448
1449 1449 if (offlining) {
1450 1450 return (STMF_STATE_OFFLINING);
1451 1451 }
1452 1452
1453 1453 return (STMF_STATE_OFFLINE);
1454 1454 }
1455 1455
1456 1456 static int
1457 1457 stmf_set_stmf_state(stmf_state_desc_t *std)
1458 1458 {
1459 1459 stmf_i_local_port_t *ilport;
1460 1460 stmf_i_lu_t *ilu;
1461 1461 stmf_state_change_info_t ssi;
1462 1462 int svc_state;
1463 1463
1464 1464 ssi.st_rflags = STMF_RFLAG_USER_REQUEST;
1465 1465 ssi.st_additional_info = NULL;
1466 1466
1467 1467 mutex_enter(&stmf_state.stmf_lock);
1468 1468 if (!stmf_state.stmf_exclusive_open) {
1469 1469 mutex_exit(&stmf_state.stmf_lock);
1470 1470 return (EACCES);
1471 1471 }
1472 1472
1473 1473 if (stmf_state.stmf_inventory_locked) {
1474 1474 mutex_exit(&stmf_state.stmf_lock);
1475 1475 return (EBUSY);
1476 1476 }
1477 1477
1478 1478 if ((std->state != STMF_STATE_ONLINE) &&
1479 1479 (std->state != STMF_STATE_OFFLINE)) {
1480 1480 mutex_exit(&stmf_state.stmf_lock);
1481 1481 return (EINVAL);
1482 1482 }
1483 1483
1484 1484 svc_state = stmf_get_service_state();
1485 1485 if ((svc_state == STMF_STATE_OFFLINING) ||
1486 1486 (svc_state == STMF_STATE_ONLINING)) {
1487 1487 mutex_exit(&stmf_state.stmf_lock);
1488 1488 return (EBUSY);
1489 1489 }
1490 1490
1491 1491 if (svc_state == STMF_STATE_OFFLINE) {
1492 1492 if (std->config_state == STMF_CONFIG_INIT) {
1493 1493 if (std->state != STMF_STATE_OFFLINE) {
1494 1494 mutex_exit(&stmf_state.stmf_lock);
1495 1495 return (EINVAL);
1496 1496 }
1497 1497 stmf_state.stmf_config_state = STMF_CONFIG_INIT;
1498 1498 stmf_delete_all_ppds();
1499 1499 stmf_view_clear_config();
1500 1500 stmf_view_init();
1501 1501 mutex_exit(&stmf_state.stmf_lock);
1502 1502 return (0);
1503 1503 }
1504 1504 if ((stmf_state.stmf_config_state == STMF_CONFIG_INIT) ||
1505 1505 (stmf_state.stmf_config_state == STMF_CONFIG_NONE)) {
1506 1506 if (std->config_state != STMF_CONFIG_INIT_DONE) {
1507 1507 mutex_exit(&stmf_state.stmf_lock);
1508 1508 return (EINVAL);
1509 1509 }
1510 1510 stmf_state.stmf_config_state = STMF_CONFIG_INIT_DONE;
1511 1511 }
1512 1512 if (std->state == STMF_STATE_OFFLINE) {
1513 1513 mutex_exit(&stmf_state.stmf_lock);
1514 1514 return (0);
1515 1515 }
1516 1516 if (stmf_state.stmf_config_state == STMF_CONFIG_INIT) {
1517 1517 mutex_exit(&stmf_state.stmf_lock);
1518 1518 return (EINVAL);
1519 1519 }
1520 1520 stmf_state.stmf_inventory_locked = 1;
1521 1521 stmf_state.stmf_service_running = 1;
1522 1522 mutex_exit(&stmf_state.stmf_lock);
1523 1523
1524 1524 for (ilport = stmf_state.stmf_ilportlist; ilport != NULL;
1525 1525 ilport = ilport->ilport_next) {
1526 1526 if (stmf_state.stmf_default_lport_state !=
1527 1527 STMF_STATE_ONLINE)
1528 1528 continue;
1529 1529 (void) stmf_ctl(STMF_CMD_LPORT_ONLINE,
1530 1530 ilport->ilport_lport, &ssi);
1531 1531 }
1532 1532
1533 1533 for (ilu = stmf_state.stmf_ilulist; ilu != NULL;
1534 1534 ilu = ilu->ilu_next) {
1535 1535 if (stmf_state.stmf_default_lu_state !=
1536 1536 STMF_STATE_ONLINE)
1537 1537 continue;
1538 1538 (void) stmf_ctl(STMF_CMD_LU_ONLINE, ilu->ilu_lu, &ssi);
1539 1539 }
1540 1540 mutex_enter(&stmf_state.stmf_lock);
1541 1541 stmf_state.stmf_inventory_locked = 0;
1542 1542 mutex_exit(&stmf_state.stmf_lock);
1543 1543 return (0);
1544 1544 }
1545 1545
1546 1546 /* svc_state is STMF_STATE_ONLINE here */
1547 1547 if ((std->state != STMF_STATE_OFFLINE) ||
1548 1548 (std->config_state == STMF_CONFIG_INIT)) {
1549 1549 mutex_exit(&stmf_state.stmf_lock);
1550 1550 return (EACCES);
1551 1551 }
1552 1552
1553 1553 stmf_state.stmf_inventory_locked = 1;
1554 1554 stmf_state.stmf_service_running = 0;
1555 1555
1556 1556 mutex_exit(&stmf_state.stmf_lock);
1557 1557 for (ilport = stmf_state.stmf_ilportlist; ilport != NULL;
1558 1558 ilport = ilport->ilport_next) {
1559 1559 if (ilport->ilport_state != STMF_STATE_ONLINE)
1560 1560 continue;
1561 1561 (void) stmf_ctl(STMF_CMD_LPORT_OFFLINE,
1562 1562 ilport->ilport_lport, &ssi);
1563 1563 }
1564 1564
1565 1565 for (ilu = stmf_state.stmf_ilulist; ilu != NULL;
1566 1566 ilu = ilu->ilu_next) {
1567 1567 if (ilu->ilu_state != STMF_STATE_ONLINE)
1568 1568 continue;
1569 1569 (void) stmf_ctl(STMF_CMD_LU_OFFLINE, ilu->ilu_lu, &ssi);
1570 1570 }
1571 1571 mutex_enter(&stmf_state.stmf_lock);
1572 1572 stmf_state.stmf_inventory_locked = 0;
1573 1573 mutex_exit(&stmf_state.stmf_lock);
1574 1574 return (0);
1575 1575 }
1576 1576
1577 1577 static int
1578 1578 stmf_get_stmf_state(stmf_state_desc_t *std)
1579 1579 {
1580 1580 mutex_enter(&stmf_state.stmf_lock);
1581 1581 std->state = stmf_get_service_state();
1582 1582 std->config_state = stmf_state.stmf_config_state;
1583 1583 mutex_exit(&stmf_state.stmf_lock);
1584 1584
1585 1585 return (0);
1586 1586 }
1587 1587
1588 1588 /*
1589 1589 * handles registration message from pppt for a logical unit
1590 1590 */
1591 1591 stmf_status_t
1592 1592 stmf_ic_lu_reg(stmf_ic_reg_dereg_lun_msg_t *msg, uint32_t type)
1593 1593 {
1594 1594 stmf_i_lu_provider_t *ilp;
1595 1595 stmf_lu_provider_t *lp;
1596 1596 mutex_enter(&stmf_state.stmf_lock);
1597 1597 for (ilp = stmf_state.stmf_ilplist; ilp != NULL; ilp = ilp->ilp_next) {
1598 1598 if (strcmp(msg->icrl_lu_provider_name,
1599 1599 ilp->ilp_lp->lp_name) == 0) {
1600 1600 lp = ilp->ilp_lp;
1601 1601 mutex_exit(&stmf_state.stmf_lock);
1602 1602 lp->lp_proxy_msg(msg->icrl_lun_id, msg->icrl_cb_arg,
1603 1603 msg->icrl_cb_arg_len, type);
1604 1604 return (STMF_SUCCESS);
1605 1605 }
1606 1606 }
1607 1607 mutex_exit(&stmf_state.stmf_lock);
1608 1608 return (STMF_SUCCESS);
1609 1609 }
1610 1610
1611 1611 /*
1612 1612 * handles de-registration message from pppt for a logical unit
1613 1613 */
1614 1614 stmf_status_t
1615 1615 stmf_ic_lu_dereg(stmf_ic_reg_dereg_lun_msg_t *msg)
1616 1616 {
1617 1617 stmf_i_lu_provider_t *ilp;
1618 1618 stmf_lu_provider_t *lp;
1619 1619 mutex_enter(&stmf_state.stmf_lock);
1620 1620 for (ilp = stmf_state.stmf_ilplist; ilp != NULL; ilp = ilp->ilp_next) {
1621 1621 if (strcmp(msg->icrl_lu_provider_name,
1622 1622 ilp->ilp_lp->lp_name) == 0) {
1623 1623 lp = ilp->ilp_lp;
1624 1624 mutex_exit(&stmf_state.stmf_lock);
1625 1625 lp->lp_proxy_msg(msg->icrl_lun_id, NULL, 0,
1626 1626 STMF_MSG_LU_DEREGISTER);
1627 1627 return (STMF_SUCCESS);
1628 1628 }
1629 1629 }
1630 1630 mutex_exit(&stmf_state.stmf_lock);
1631 1631 return (STMF_SUCCESS);
1632 1632 }
1633 1633
1634 1634 /*
1635 1635 * helper function to find a task that matches a task_msgid
1636 1636 */
1637 1637 scsi_task_t *
1638 1638 find_task_from_msgid(uint8_t *lu_id, stmf_ic_msgid_t task_msgid)
1639 1639 {
1640 1640 stmf_i_lu_t *ilu;
1641 1641 stmf_i_scsi_task_t *itask;
1642 1642
1643 1643 mutex_enter(&stmf_state.stmf_lock);
1644 1644 for (ilu = stmf_state.stmf_ilulist; ilu != NULL; ilu = ilu->ilu_next) {
1645 1645 if (bcmp(lu_id, ilu->ilu_lu->lu_id->ident, 16) == 0) {
1646 1646 break;
1647 1647 }
1648 1648 }
1649 1649
1650 1650 if (ilu == NULL) {
1651 1651 mutex_exit(&stmf_state.stmf_lock);
1652 1652 return (NULL);
1653 1653 }
1654 1654
1655 1655 mutex_enter(&ilu->ilu_task_lock);
1656 1656 for (itask = ilu->ilu_tasks; itask != NULL;
1657 1657 itask = itask->itask_lu_next) {
1658 1658 if (itask->itask_flags & (ITASK_IN_FREE_LIST |
1659 1659 ITASK_BEING_ABORTED)) {
1660 1660 continue;
1661 1661 }
1662 1662 if (itask->itask_proxy_msg_id == task_msgid) {
1663 1663 break;
1664 1664 }
1665 1665 }
1666 1666 mutex_exit(&ilu->ilu_task_lock);
1667 1667 mutex_exit(&stmf_state.stmf_lock);
1668 1668
1669 1669 if (itask != NULL) {
1670 1670 return (itask->itask_task);
1671 1671 } else {
1672 1672 /* task not found. Likely already aborted. */
1673 1673 return (NULL);
1674 1674 }
1675 1675 }
1676 1676
1677 1677 /*
1678 1678 * message received from pppt/ic
1679 1679 */
1680 1680 stmf_status_t
1681 1681 stmf_msg_rx(stmf_ic_msg_t *msg)
1682 1682 {
1683 1683 mutex_enter(&stmf_state.stmf_lock);
1684 1684 if (stmf_state.stmf_alua_state != 1) {
1685 1685 mutex_exit(&stmf_state.stmf_lock);
1686 1686 cmn_err(CE_WARN, "stmf alua state is disabled");
1687 1687 ic_msg_free(msg);
1688 1688 return (STMF_FAILURE);
1689 1689 }
1690 1690 mutex_exit(&stmf_state.stmf_lock);
1691 1691
1692 1692 switch (msg->icm_msg_type) {
1693 1693 case STMF_ICM_REGISTER_LUN:
1694 1694 (void) stmf_ic_lu_reg(
1695 1695 (stmf_ic_reg_dereg_lun_msg_t *)msg->icm_msg,
1696 1696 STMF_MSG_LU_REGISTER);
1697 1697 break;
1698 1698 case STMF_ICM_LUN_ACTIVE:
1699 1699 (void) stmf_ic_lu_reg(
1700 1700 (stmf_ic_reg_dereg_lun_msg_t *)msg->icm_msg,
1701 1701 STMF_MSG_LU_ACTIVE);
1702 1702 break;
1703 1703 case STMF_ICM_DEREGISTER_LUN:
1704 1704 (void) stmf_ic_lu_dereg(
1705 1705 (stmf_ic_reg_dereg_lun_msg_t *)msg->icm_msg);
1706 1706 break;
1707 1707 case STMF_ICM_SCSI_DATA:
1708 1708 (void) stmf_ic_rx_scsi_data(
1709 1709 (stmf_ic_scsi_data_msg_t *)msg->icm_msg);
1710 1710 break;
1711 1711 case STMF_ICM_SCSI_STATUS:
1712 1712 (void) stmf_ic_rx_scsi_status(
1713 1713 (stmf_ic_scsi_status_msg_t *)msg->icm_msg);
1714 1714 break;
1715 1715 case STMF_ICM_STATUS:
1716 1716 (void) stmf_ic_rx_status(
1717 1717 (stmf_ic_status_msg_t *)msg->icm_msg);
1718 1718 break;
1719 1719 default:
1720 1720 cmn_err(CE_WARN, "unknown message received %d",
1721 1721 msg->icm_msg_type);
1722 1722 ic_msg_free(msg);
1723 1723 return (STMF_FAILURE);
1724 1724 }
1725 1725 ic_msg_free(msg);
1726 1726 return (STMF_SUCCESS);
1727 1727 }
1728 1728
1729 1729 stmf_status_t
1730 1730 stmf_ic_rx_status(stmf_ic_status_msg_t *msg)
1731 1731 {
1732 1732 stmf_i_local_port_t *ilport;
1733 1733
1734 1734 if (msg->ics_msg_type != STMF_ICM_REGISTER_PROXY_PORT) {
1735 1735 /* for now, ignore other message status */
1736 1736 return (STMF_SUCCESS);
1737 1737 }
1738 1738
1739 1739 if (msg->ics_status != STMF_SUCCESS) {
1740 1740 return (STMF_SUCCESS);
1741 1741 }
1742 1742
1743 1743 mutex_enter(&stmf_state.stmf_lock);
1744 1744 for (ilport = stmf_state.stmf_ilportlist; ilport != NULL;
1745 1745 ilport = ilport->ilport_next) {
1746 1746 if (msg->ics_msgid == ilport->ilport_reg_msgid) {
1747 1747 ilport->ilport_proxy_registered = 1;
1748 1748 break;
1749 1749 }
1750 1750 }
1751 1751 mutex_exit(&stmf_state.stmf_lock);
1752 1752 return (STMF_SUCCESS);
1753 1753 }
1754 1754
1755 1755 /*
1756 1756 * handles scsi status message from pppt
1757 1757 */
1758 1758 stmf_status_t
1759 1759 stmf_ic_rx_scsi_status(stmf_ic_scsi_status_msg_t *msg)
1760 1760 {
1761 1761 scsi_task_t *task;
1762 1762
1763 1763 /* is this a task management command */
1764 1764 if (msg->icss_task_msgid & MSG_ID_TM_BIT) {
1765 1765 return (STMF_SUCCESS);
1766 1766 }
1767 1767
1768 1768 task = find_task_from_msgid(msg->icss_lun_id, msg->icss_task_msgid);
1769 1769
1770 1770 if (task == NULL) {
1771 1771 return (STMF_SUCCESS);
1772 1772 }
1773 1773
1774 1774 task->task_scsi_status = msg->icss_status;
1775 1775 task->task_sense_data = msg->icss_sense;
1776 1776 task->task_sense_length = msg->icss_sense_len;
1777 1777 (void) stmf_send_scsi_status(task, STMF_IOF_LU_DONE);
1778 1778
1779 1779 return (STMF_SUCCESS);
1780 1780 }
1781 1781
1782 1782 /*
1783 1783 * handles scsi data message from pppt
1784 1784 */
1785 1785 stmf_status_t
1786 1786 stmf_ic_rx_scsi_data(stmf_ic_scsi_data_msg_t *msg)
1787 1787 {
1788 1788 stmf_i_scsi_task_t *itask;
1789 1789 scsi_task_t *task;
1790 1790 stmf_xfer_data_t *xd = NULL;
1791 1791 stmf_data_buf_t *dbuf;
1792 1792 uint32_t sz, minsz, xd_sz, asz;
1793 1793
1794 1794 /* is this a task management command */
1795 1795 if (msg->icsd_task_msgid & MSG_ID_TM_BIT) {
1796 1796 return (STMF_SUCCESS);
1797 1797 }
1798 1798
1799 1799 task = find_task_from_msgid(msg->icsd_lun_id, msg->icsd_task_msgid);
1800 1800 if (task == NULL) {
1801 1801 stmf_ic_msg_t *ic_xfer_done_msg = NULL;
1802 1802 static uint64_t data_msg_id;
1803 1803 stmf_status_t ic_ret = STMF_FAILURE;
1804 1804 mutex_enter(&stmf_state.stmf_lock);
1805 1805 data_msg_id = stmf_proxy_msg_id++;
1806 1806 mutex_exit(&stmf_state.stmf_lock);
1807 1807 /*
1808 1808 * send xfer done status to pppt
1809 1809 * for now, set the session id to 0 as we cannot
1810 1810 * ascertain it since we cannot find the task
1811 1811 */
1812 1812 ic_xfer_done_msg = ic_scsi_data_xfer_done_msg_alloc(
1813 1813 msg->icsd_task_msgid, 0, STMF_FAILURE, data_msg_id);
1814 1814 if (ic_xfer_done_msg) {
1815 1815 ic_ret = ic_tx_msg(ic_xfer_done_msg);
1816 1816 if (ic_ret != STMF_IC_MSG_SUCCESS) {
1817 1817 cmn_err(CE_WARN, "unable to xmit proxy msg");
1818 1818 }
1819 1819 }
1820 1820 return (STMF_FAILURE);
1821 1821 }
1822 1822
1823 1823 itask = (stmf_i_scsi_task_t *)task->task_stmf_private;
1824 1824 dbuf = itask->itask_proxy_dbuf;
1825 1825
1826 1826 task->task_cmd_xfer_length += msg->icsd_data_len;
1827 1827
1828 1828 if (task->task_additional_flags &
1829 1829 TASK_AF_NO_EXPECTED_XFER_LENGTH) {
1830 1830 task->task_expected_xfer_length =
1831 1831 task->task_cmd_xfer_length;
1832 1832 }
1833 1833
1834 1834 sz = min(task->task_expected_xfer_length,
1835 1835 task->task_cmd_xfer_length);
1836 1836
1837 1837 xd_sz = msg->icsd_data_len;
1838 1838 asz = xd_sz + sizeof (*xd) - 4;
1839 1839 xd = (stmf_xfer_data_t *)kmem_zalloc(asz, KM_NOSLEEP);
1840 1840
1841 1841 if (xd == NULL) {
1842 1842 stmf_abort(STMF_QUEUE_TASK_ABORT, task,
1843 1843 STMF_ALLOC_FAILURE, NULL);
1844 1844 return (STMF_FAILURE);
1845 1845 }
1846 1846
1847 1847 xd->alloc_size = asz;
1848 1848 xd->size_left = xd_sz;
1849 1849 bcopy(msg->icsd_data, xd->buf, xd_sz);
1850 1850
1851 1851 sz = min(sz, xd->size_left);
1852 1852 xd->size_left = sz;
1853 1853 minsz = min(512, sz);
1854 1854
1855 1855 if (dbuf == NULL)
1856 1856 dbuf = stmf_alloc_dbuf(task, sz, &minsz, 0);
1857 1857 if (dbuf == NULL) {
1858 1858 kmem_free(xd, xd->alloc_size);
1859 1859 stmf_abort(STMF_QUEUE_TASK_ABORT, task,
1860 1860 STMF_ALLOC_FAILURE, NULL);
1861 1861 return (STMF_FAILURE);
1862 1862 }
1863 1863 dbuf->db_lu_private = xd;
1864 1864 dbuf->db_relative_offset = task->task_nbytes_transferred;
1865 1865 stmf_xd_to_dbuf(dbuf, 0);
1866 1866
1867 1867 dbuf->db_flags = DB_DIRECTION_TO_RPORT;
1868 1868 (void) stmf_xfer_data(task, dbuf, 0);
1869 1869 return (STMF_SUCCESS);
1870 1870 }
1871 1871
1872 1872 stmf_status_t
1873 1873 stmf_proxy_scsi_cmd(scsi_task_t *task, stmf_data_buf_t *dbuf)
1874 1874 {
1875 1875 stmf_i_scsi_task_t *itask =
1876 1876 (stmf_i_scsi_task_t *)task->task_stmf_private;
1877 1877 stmf_i_local_port_t *ilport =
1878 1878 (stmf_i_local_port_t *)task->task_lport->lport_stmf_private;
1879 1879 stmf_ic_msg_t *ic_cmd_msg;
1880 1880 stmf_ic_msg_status_t ic_ret;
1881 1881 stmf_status_t ret = STMF_FAILURE;
1882 1882
1883 1883 if (stmf_state.stmf_alua_state != 1) {
1884 1884 cmn_err(CE_WARN, "stmf alua state is disabled");
1885 1885 return (STMF_FAILURE);
1886 1886 }
1887 1887
1888 1888 if (ilport->ilport_proxy_registered == 0) {
1889 1889 return (STMF_FAILURE);
1890 1890 }
1891 1891
1892 1892 mutex_enter(&stmf_state.stmf_lock);
1893 1893 itask->itask_proxy_msg_id = stmf_proxy_msg_id++;
1894 1894 mutex_exit(&stmf_state.stmf_lock);
1895 1895 itask->itask_proxy_dbuf = dbuf;
1896 1896
1897 1897 /*
1898 1898 * stmf will now take over the task handling for this task
1899 1899 * but it still needs to be treated differently from other
1900 1900 * default handled tasks, hence the ITASK_PROXY_TASK.
1901 1901 * If this is a task management function, we're really just
1902 1902 * duping the command to the peer. Set the TM bit so that
1903 1903 * we can recognize this on return since we won't be completing
1904 1904 * the proxied task in that case.
1905 1905 */
1906 1906 if (task->task_mgmt_function) {
1907 1907 itask->itask_proxy_msg_id |= MSG_ID_TM_BIT;
1908 1908 } else {
1909 1909 uint32_t new, old;
1910 1910 do {
1911 1911 new = old = itask->itask_flags;
1912 1912 if (new & ITASK_BEING_ABORTED)
1913 1913 return (STMF_FAILURE);
1914 1914 new |= ITASK_DEFAULT_HANDLING | ITASK_PROXY_TASK;
1915 1915 } while (atomic_cas_32(&itask->itask_flags, old, new) != old);
1916 1916 }
1917 1917 if (dbuf) {
1918 1918 ic_cmd_msg = ic_scsi_cmd_msg_alloc(itask->itask_proxy_msg_id,
1919 1919 task, dbuf->db_data_size, dbuf->db_sglist[0].seg_addr,
1920 1920 itask->itask_proxy_msg_id);
1921 1921 } else {
1922 1922 ic_cmd_msg = ic_scsi_cmd_msg_alloc(itask->itask_proxy_msg_id,
1923 1923 task, 0, NULL, itask->itask_proxy_msg_id);
1924 1924 }
1925 1925 if (ic_cmd_msg) {
1926 1926 ic_ret = ic_tx_msg(ic_cmd_msg);
1927 1927 if (ic_ret == STMF_IC_MSG_SUCCESS) {
1928 1928 ret = STMF_SUCCESS;
1929 1929 }
1930 1930 }
1931 1931 return (ret);
1932 1932 }
1933 1933
1934 1934
1935 1935 stmf_status_t
1936 1936 pppt_modload()
1937 1937 {
1938 1938 int error;
1939 1939
1940 1940 if (pppt_mod == NULL && ((pppt_mod =
1941 1941 ddi_modopen("drv/pppt", KRTLD_MODE_FIRST, &error)) == NULL)) {
1942 1942 cmn_err(CE_WARN, "Unable to load pppt");
1943 1943 return (STMF_FAILURE);
1944 1944 }
1945 1945
1946 1946 if (ic_reg_port_msg_alloc == NULL && ((ic_reg_port_msg_alloc =
1947 1947 (stmf_ic_reg_port_msg_alloc_func_t)
1948 1948 ddi_modsym(pppt_mod, "stmf_ic_reg_port_msg_alloc",
1949 1949 &error)) == NULL)) {
1950 1950 cmn_err(CE_WARN,
1951 1951 "Unable to find symbol - stmf_ic_reg_port_msg_alloc");
1952 1952 return (STMF_FAILURE);
1953 1953 }
1954 1954
1955 1955
1956 1956 if (ic_dereg_port_msg_alloc == NULL && ((ic_dereg_port_msg_alloc =
1957 1957 (stmf_ic_dereg_port_msg_alloc_func_t)
1958 1958 ddi_modsym(pppt_mod, "stmf_ic_dereg_port_msg_alloc",
1959 1959 &error)) == NULL)) {
1960 1960 cmn_err(CE_WARN,
1961 1961 "Unable to find symbol - stmf_ic_dereg_port_msg_alloc");
1962 1962 return (STMF_FAILURE);
1963 1963 }
1964 1964
1965 1965 if (ic_reg_lun_msg_alloc == NULL && ((ic_reg_lun_msg_alloc =
1966 1966 (stmf_ic_reg_lun_msg_alloc_func_t)
1967 1967 ddi_modsym(pppt_mod, "stmf_ic_reg_lun_msg_alloc",
1968 1968 &error)) == NULL)) {
1969 1969 cmn_err(CE_WARN,
1970 1970 "Unable to find symbol - stmf_ic_reg_lun_msg_alloc");
1971 1971 return (STMF_FAILURE);
1972 1972 }
1973 1973
1974 1974 if (ic_lun_active_msg_alloc == NULL && ((ic_lun_active_msg_alloc =
1975 1975 (stmf_ic_lun_active_msg_alloc_func_t)
1976 1976 ddi_modsym(pppt_mod, "stmf_ic_lun_active_msg_alloc",
1977 1977 &error)) == NULL)) {
1978 1978 cmn_err(CE_WARN,
1979 1979 "Unable to find symbol - stmf_ic_lun_active_msg_alloc");
1980 1980 return (STMF_FAILURE);
1981 1981 }
1982 1982
1983 1983 if (ic_dereg_lun_msg_alloc == NULL && ((ic_dereg_lun_msg_alloc =
1984 1984 (stmf_ic_dereg_lun_msg_alloc_func_t)
1985 1985 ddi_modsym(pppt_mod, "stmf_ic_dereg_lun_msg_alloc",
1986 1986 &error)) == NULL)) {
1987 1987 cmn_err(CE_WARN,
1988 1988 "Unable to find symbol - stmf_ic_dereg_lun_msg_alloc");
1989 1989 return (STMF_FAILURE);
1990 1990 }
1991 1991
1992 1992 if (ic_scsi_cmd_msg_alloc == NULL && ((ic_scsi_cmd_msg_alloc =
1993 1993 (stmf_ic_scsi_cmd_msg_alloc_func_t)
1994 1994 ddi_modsym(pppt_mod, "stmf_ic_scsi_cmd_msg_alloc",
1995 1995 &error)) == NULL)) {
1996 1996 cmn_err(CE_WARN,
1997 1997 "Unable to find symbol - stmf_ic_scsi_cmd_msg_alloc");
1998 1998 return (STMF_FAILURE);
1999 1999 }
2000 2000
2001 2001 if (ic_scsi_data_xfer_done_msg_alloc == NULL &&
2002 2002 ((ic_scsi_data_xfer_done_msg_alloc =
2003 2003 (stmf_ic_scsi_data_xfer_done_msg_alloc_func_t)
2004 2004 ddi_modsym(pppt_mod, "stmf_ic_scsi_data_xfer_done_msg_alloc",
2005 2005 &error)) == NULL)) {
2006 2006 cmn_err(CE_WARN,
2007 2007 "Unable to find symbol -"
2008 2008 "stmf_ic_scsi_data_xfer_done_msg_alloc");
2009 2009 return (STMF_FAILURE);
2010 2010 }
2011 2011
2012 2012 if (ic_session_reg_msg_alloc == NULL &&
2013 2013 ((ic_session_reg_msg_alloc =
2014 2014 (stmf_ic_session_create_msg_alloc_func_t)
2015 2015 ddi_modsym(pppt_mod, "stmf_ic_session_create_msg_alloc",
2016 2016 &error)) == NULL)) {
2017 2017 cmn_err(CE_WARN,
2018 2018 "Unable to find symbol -"
2019 2019 "stmf_ic_session_create_msg_alloc");
2020 2020 return (STMF_FAILURE);
2021 2021 }
2022 2022
2023 2023 if (ic_session_dereg_msg_alloc == NULL &&
2024 2024 ((ic_session_dereg_msg_alloc =
2025 2025 (stmf_ic_session_destroy_msg_alloc_func_t)
2026 2026 ddi_modsym(pppt_mod, "stmf_ic_session_destroy_msg_alloc",
2027 2027 &error)) == NULL)) {
2028 2028 cmn_err(CE_WARN,
2029 2029 "Unable to find symbol -"
2030 2030 "stmf_ic_session_destroy_msg_alloc");
2031 2031 return (STMF_FAILURE);
2032 2032 }
2033 2033
2034 2034 if (ic_tx_msg == NULL && ((ic_tx_msg =
2035 2035 (stmf_ic_tx_msg_func_t)ddi_modsym(pppt_mod, "stmf_ic_tx_msg",
2036 2036 &error)) == NULL)) {
2037 2037 cmn_err(CE_WARN, "Unable to find symbol - stmf_ic_tx_msg");
2038 2038 return (STMF_FAILURE);
2039 2039 }
2040 2040
2041 2041 if (ic_msg_free == NULL && ((ic_msg_free =
2042 2042 (stmf_ic_msg_free_func_t)ddi_modsym(pppt_mod, "stmf_ic_msg_free",
2043 2043 &error)) == NULL)) {
2044 2044 cmn_err(CE_WARN, "Unable to find symbol - stmf_ic_msg_free");
2045 2045 return (STMF_FAILURE);
2046 2046 }
2047 2047 return (STMF_SUCCESS);
2048 2048 }
2049 2049
2050 2050 static void
2051 2051 stmf_get_alua_state(stmf_alua_state_desc_t *alua_state)
2052 2052 {
2053 2053 mutex_enter(&stmf_state.stmf_lock);
2054 2054 alua_state->alua_node = stmf_state.stmf_alua_node;
2055 2055 alua_state->alua_state = stmf_state.stmf_alua_state;
2056 2056 mutex_exit(&stmf_state.stmf_lock);
2057 2057 }
2058 2058
2059 2059
2060 2060 static int
2061 2061 stmf_set_alua_state(stmf_alua_state_desc_t *alua_state)
2062 2062 {
2063 2063 stmf_i_local_port_t *ilport;
2064 2064 stmf_i_lu_t *ilu;
2065 2065 stmf_lu_t *lu;
2066 2066 stmf_ic_msg_status_t ic_ret;
2067 2067 stmf_ic_msg_t *ic_reg_lun, *ic_reg_port;
2068 2068 stmf_local_port_t *lport;
2069 2069 int ret = 0;
2070 2070
2071 2071 if (alua_state->alua_state > 1 || alua_state->alua_node > 1) {
2072 2072 return (EINVAL);
2073 2073 }
2074 2074
2075 2075 mutex_enter(&stmf_state.stmf_lock);
2076 2076 if (alua_state->alua_state == 1) {
2077 2077 if (pppt_modload() == STMF_FAILURE) {
2078 2078 ret = EIO;
2079 2079 goto err;
2080 2080 }
2081 2081 if (alua_state->alua_node != 0) {
2082 2082 /* reset existing rtpids to new base */
2083 2083 stmf_rtpid_counter = 255;
2084 2084 }
2085 2085 stmf_state.stmf_alua_node = alua_state->alua_node;
2086 2086 stmf_state.stmf_alua_state = 1;
|
↓ open down ↓ |
2086 lines elided |
↑ open up ↑ |
2087 2087 /* register existing local ports with ppp */
2088 2088 for (ilport = stmf_state.stmf_ilportlist; ilport != NULL;
2089 2089 ilport = ilport->ilport_next) {
2090 2090 /* skip standby ports and non-alua participants */
2091 2091 if (ilport->ilport_standby == 1 ||
2092 2092 ilport->ilport_alua == 0) {
2093 2093 continue;
2094 2094 }
2095 2095 if (alua_state->alua_node != 0) {
2096 2096 ilport->ilport_rtpid =
2097 - atomic_add_16_nv(&stmf_rtpid_counter, 1);
2097 + atomic_inc_16_nv(&stmf_rtpid_counter);
2098 2098 }
2099 2099 lport = ilport->ilport_lport;
2100 2100 ic_reg_port = ic_reg_port_msg_alloc(
2101 2101 lport->lport_id, ilport->ilport_rtpid,
2102 2102 0, NULL, stmf_proxy_msg_id);
2103 2103 if (ic_reg_port) {
2104 2104 ic_ret = ic_tx_msg(ic_reg_port);
2105 2105 if (ic_ret == STMF_IC_MSG_SUCCESS) {
2106 2106 ilport->ilport_reg_msgid =
2107 2107 stmf_proxy_msg_id++;
2108 2108 } else {
2109 2109 cmn_err(CE_WARN,
2110 2110 "error on port registration "
2111 2111 "port - %s",
2112 2112 ilport->ilport_kstat_tgt_name);
2113 2113 }
2114 2114 }
2115 2115 }
2116 2116 /* register existing logical units */
2117 2117 for (ilu = stmf_state.stmf_ilulist; ilu != NULL;
2118 2118 ilu = ilu->ilu_next) {
2119 2119 if (ilu->ilu_access != STMF_LU_ACTIVE) {
2120 2120 continue;
2121 2121 }
2122 2122 /* register with proxy module */
2123 2123 lu = ilu->ilu_lu;
2124 2124 if (lu->lu_lp && lu->lu_lp->lp_lpif_rev == LPIF_REV_2 &&
2125 2125 lu->lu_lp->lp_alua_support) {
2126 2126 ilu->ilu_alua = 1;
2127 2127 /* allocate the register message */
2128 2128 ic_reg_lun = ic_reg_lun_msg_alloc(
2129 2129 lu->lu_id->ident, lu->lu_lp->lp_name,
2130 2130 lu->lu_proxy_reg_arg_len,
2131 2131 (uint8_t *)lu->lu_proxy_reg_arg,
2132 2132 stmf_proxy_msg_id);
2133 2133 /* send the message */
2134 2134 if (ic_reg_lun) {
2135 2135 ic_ret = ic_tx_msg(ic_reg_lun);
2136 2136 if (ic_ret == STMF_IC_MSG_SUCCESS) {
2137 2137 stmf_proxy_msg_id++;
2138 2138 }
2139 2139 }
2140 2140 }
2141 2141 }
2142 2142 } else {
2143 2143 stmf_state.stmf_alua_state = 0;
2144 2144 }
2145 2145
2146 2146 err:
2147 2147 mutex_exit(&stmf_state.stmf_lock);
2148 2148 return (ret);
2149 2149 }
2150 2150
2151 2151
2152 2152 typedef struct {
2153 2153 void *bp; /* back pointer from internal struct to main struct */
2154 2154 int alloc_size;
2155 2155 } __istmf_t;
2156 2156
2157 2157 typedef struct {
2158 2158 __istmf_t *fp; /* Framework private */
2159 2159 void *cp; /* Caller private */
2160 2160 void *ss; /* struct specific */
2161 2161 } __stmf_t;
2162 2162
2163 2163 static struct {
2164 2164 int shared;
2165 2165 int fw_private;
2166 2166 } stmf_sizes[] = { { 0, 0 },
2167 2167 { GET_STRUCT_SIZE(stmf_lu_provider_t),
2168 2168 GET_STRUCT_SIZE(stmf_i_lu_provider_t) },
2169 2169 { GET_STRUCT_SIZE(stmf_port_provider_t),
2170 2170 GET_STRUCT_SIZE(stmf_i_port_provider_t) },
2171 2171 { GET_STRUCT_SIZE(stmf_local_port_t),
2172 2172 GET_STRUCT_SIZE(stmf_i_local_port_t) },
2173 2173 { GET_STRUCT_SIZE(stmf_lu_t),
2174 2174 GET_STRUCT_SIZE(stmf_i_lu_t) },
2175 2175 { GET_STRUCT_SIZE(stmf_scsi_session_t),
2176 2176 GET_STRUCT_SIZE(stmf_i_scsi_session_t) },
2177 2177 { GET_STRUCT_SIZE(scsi_task_t),
2178 2178 GET_STRUCT_SIZE(stmf_i_scsi_task_t) },
2179 2179 { GET_STRUCT_SIZE(stmf_data_buf_t),
2180 2180 GET_STRUCT_SIZE(__istmf_t) },
2181 2181 { GET_STRUCT_SIZE(stmf_dbuf_store_t),
2182 2182 GET_STRUCT_SIZE(__istmf_t) }
2183 2183
2184 2184 };
2185 2185
2186 2186 void *
2187 2187 stmf_alloc(stmf_struct_id_t struct_id, int additional_size, int flags)
2188 2188 {
2189 2189 int stmf_size;
2190 2190 int kmem_flag;
2191 2191 __stmf_t *sh;
2192 2192
2193 2193 if ((struct_id == 0) || (struct_id >= STMF_MAX_STRUCT_IDS))
2194 2194 return (NULL);
2195 2195
2196 2196 if ((curthread->t_flag & T_INTR_THREAD) || (flags & AF_FORCE_NOSLEEP)) {
2197 2197 kmem_flag = KM_NOSLEEP;
2198 2198 } else {
2199 2199 kmem_flag = KM_SLEEP;
2200 2200 }
2201 2201
2202 2202 additional_size = (additional_size + 7) & (~7);
2203 2203 stmf_size = stmf_sizes[struct_id].shared +
2204 2204 stmf_sizes[struct_id].fw_private + additional_size;
2205 2205
2206 2206 if (flags & AF_DONTZERO)
2207 2207 sh = (__stmf_t *)kmem_alloc(stmf_size, kmem_flag);
2208 2208 else
2209 2209 sh = (__stmf_t *)kmem_zalloc(stmf_size, kmem_flag);
2210 2210
2211 2211 if (sh == NULL)
2212 2212 return (NULL);
2213 2213
2214 2214 /*
2215 2215 * In principle, the implementation inside stmf_alloc should not
2216 2216 * be changed anyway. But the original order of framework private
2217 2217 * data and caller private data does not support sglist in the caller
2218 2218 * private data.
2219 2219 * To work around this, the memory segments of framework private
2220 2220 * data and caller private data are re-ordered here.
2221 2221 * A better solution is to provide a specific interface to allocate
2222 2222 * the sglist, then we will not need this workaround any more.
2223 2223 * But before the new interface is available, the memory segment
2224 2224 * ordering should be kept as is.
2225 2225 */
2226 2226 sh->cp = GET_BYTE_OFFSET(sh, stmf_sizes[struct_id].shared);
2227 2227 sh->fp = (__istmf_t *)GET_BYTE_OFFSET(sh,
2228 2228 stmf_sizes[struct_id].shared + additional_size);
2229 2229
2230 2230 sh->fp->bp = sh;
2231 2231 /* Just store the total size instead of storing additional size */
2232 2232 sh->fp->alloc_size = stmf_size;
2233 2233
2234 2234 return (sh);
2235 2235 }
2236 2236
2237 2237 void
2238 2238 stmf_free(void *ptr)
2239 2239 {
2240 2240 __stmf_t *sh = (__stmf_t *)ptr;
2241 2241
2242 2242 /*
2243 2243 * So far we dont need any struct specific processing. If such
2244 2244 * a need ever arises, then store the struct id in the framework
2245 2245 * private section and get it here as sh->fp->struct_id.
2246 2246 */
2247 2247 kmem_free(ptr, sh->fp->alloc_size);
2248 2248 }
2249 2249
2250 2250 /*
2251 2251 * Given a pointer to stmf_lu_t, verifies if this lu is registered with the
2252 2252 * framework and returns a pointer to framework private data for the lu.
2253 2253 * Returns NULL if the lu was not found.
2254 2254 */
2255 2255 stmf_i_lu_t *
2256 2256 stmf_lookup_lu(stmf_lu_t *lu)
2257 2257 {
2258 2258 stmf_i_lu_t *ilu;
2259 2259 ASSERT(mutex_owned(&stmf_state.stmf_lock));
2260 2260
2261 2261 for (ilu = stmf_state.stmf_ilulist; ilu != NULL; ilu = ilu->ilu_next) {
2262 2262 if (ilu->ilu_lu == lu)
2263 2263 return (ilu);
2264 2264 }
2265 2265 return (NULL);
2266 2266 }
2267 2267
2268 2268 /*
2269 2269 * Given a pointer to stmf_local_port_t, verifies if this lport is registered
2270 2270 * with the framework and returns a pointer to framework private data for
2271 2271 * the lport.
2272 2272 * Returns NULL if the lport was not found.
2273 2273 */
2274 2274 stmf_i_local_port_t *
2275 2275 stmf_lookup_lport(stmf_local_port_t *lport)
2276 2276 {
2277 2277 stmf_i_local_port_t *ilport;
2278 2278 ASSERT(mutex_owned(&stmf_state.stmf_lock));
2279 2279
2280 2280 for (ilport = stmf_state.stmf_ilportlist; ilport != NULL;
2281 2281 ilport = ilport->ilport_next) {
2282 2282 if (ilport->ilport_lport == lport)
2283 2283 return (ilport);
2284 2284 }
2285 2285 return (NULL);
2286 2286 }
2287 2287
2288 2288 stmf_status_t
2289 2289 stmf_register_lu_provider(stmf_lu_provider_t *lp)
2290 2290 {
2291 2291 stmf_i_lu_provider_t *ilp = (stmf_i_lu_provider_t *)lp->lp_stmf_private;
2292 2292 stmf_pp_data_t *ppd;
2293 2293 uint32_t cb_flags;
2294 2294
2295 2295 if (lp->lp_lpif_rev != LPIF_REV_1 && lp->lp_lpif_rev != LPIF_REV_2)
2296 2296 return (STMF_FAILURE);
2297 2297
2298 2298 mutex_enter(&stmf_state.stmf_lock);
2299 2299 ilp->ilp_next = stmf_state.stmf_ilplist;
2300 2300 stmf_state.stmf_ilplist = ilp;
2301 2301 stmf_state.stmf_nlps++;
2302 2302
2303 2303 /* See if we need to do a callback */
2304 2304 for (ppd = stmf_state.stmf_ppdlist; ppd != NULL; ppd = ppd->ppd_next) {
2305 2305 if (strcmp(ppd->ppd_name, lp->lp_name) == 0) {
2306 2306 break;
2307 2307 }
2308 2308 }
2309 2309 if ((ppd == NULL) || (ppd->ppd_nv == NULL)) {
2310 2310 goto rlp_bail_out;
2311 2311 }
2312 2312 ilp->ilp_ppd = ppd;
2313 2313 ppd->ppd_provider = ilp;
2314 2314 if (lp->lp_cb == NULL)
2315 2315 goto rlp_bail_out;
2316 2316 ilp->ilp_cb_in_progress = 1;
2317 2317 cb_flags = STMF_PCB_PREG_COMPLETE;
2318 2318 if (stmf_state.stmf_config_state == STMF_CONFIG_INIT)
2319 2319 cb_flags |= STMF_PCB_STMF_ONLINING;
2320 2320 mutex_exit(&stmf_state.stmf_lock);
2321 2321 lp->lp_cb(lp, STMF_PROVIDER_DATA_UPDATED, ppd->ppd_nv, cb_flags);
2322 2322 mutex_enter(&stmf_state.stmf_lock);
2323 2323 ilp->ilp_cb_in_progress = 0;
2324 2324
2325 2325 rlp_bail_out:
2326 2326 mutex_exit(&stmf_state.stmf_lock);
2327 2327
2328 2328 return (STMF_SUCCESS);
2329 2329 }
2330 2330
2331 2331 stmf_status_t
2332 2332 stmf_deregister_lu_provider(stmf_lu_provider_t *lp)
2333 2333 {
2334 2334 stmf_i_lu_provider_t **ppilp;
2335 2335 stmf_i_lu_provider_t *ilp = (stmf_i_lu_provider_t *)lp->lp_stmf_private;
2336 2336
2337 2337 mutex_enter(&stmf_state.stmf_lock);
2338 2338 if (ilp->ilp_nlus || ilp->ilp_cb_in_progress) {
2339 2339 mutex_exit(&stmf_state.stmf_lock);
2340 2340 return (STMF_BUSY);
2341 2341 }
2342 2342 for (ppilp = &stmf_state.stmf_ilplist; *ppilp != NULL;
2343 2343 ppilp = &((*ppilp)->ilp_next)) {
2344 2344 if (*ppilp == ilp) {
2345 2345 *ppilp = ilp->ilp_next;
2346 2346 stmf_state.stmf_nlps--;
2347 2347 if (ilp->ilp_ppd) {
2348 2348 ilp->ilp_ppd->ppd_provider = NULL;
2349 2349 ilp->ilp_ppd = NULL;
2350 2350 }
2351 2351 mutex_exit(&stmf_state.stmf_lock);
2352 2352 return (STMF_SUCCESS);
2353 2353 }
2354 2354 }
2355 2355 mutex_exit(&stmf_state.stmf_lock);
2356 2356 return (STMF_NOT_FOUND);
2357 2357 }
2358 2358
2359 2359 stmf_status_t
2360 2360 stmf_register_port_provider(stmf_port_provider_t *pp)
2361 2361 {
2362 2362 stmf_i_port_provider_t *ipp =
2363 2363 (stmf_i_port_provider_t *)pp->pp_stmf_private;
2364 2364 stmf_pp_data_t *ppd;
2365 2365 uint32_t cb_flags;
2366 2366
2367 2367 if (pp->pp_portif_rev != PORTIF_REV_1)
2368 2368 return (STMF_FAILURE);
2369 2369
2370 2370 mutex_enter(&stmf_state.stmf_lock);
2371 2371 ipp->ipp_next = stmf_state.stmf_ipplist;
2372 2372 stmf_state.stmf_ipplist = ipp;
2373 2373 stmf_state.stmf_npps++;
2374 2374 /* See if we need to do a callback */
2375 2375 for (ppd = stmf_state.stmf_ppdlist; ppd != NULL; ppd = ppd->ppd_next) {
2376 2376 if (strcmp(ppd->ppd_name, pp->pp_name) == 0) {
2377 2377 break;
2378 2378 }
2379 2379 }
2380 2380 if ((ppd == NULL) || (ppd->ppd_nv == NULL)) {
2381 2381 goto rpp_bail_out;
2382 2382 }
2383 2383 ipp->ipp_ppd = ppd;
2384 2384 ppd->ppd_provider = ipp;
2385 2385 if (pp->pp_cb == NULL)
2386 2386 goto rpp_bail_out;
2387 2387 ipp->ipp_cb_in_progress = 1;
2388 2388 cb_flags = STMF_PCB_PREG_COMPLETE;
2389 2389 if (stmf_state.stmf_config_state == STMF_CONFIG_INIT)
2390 2390 cb_flags |= STMF_PCB_STMF_ONLINING;
2391 2391 mutex_exit(&stmf_state.stmf_lock);
2392 2392 pp->pp_cb(pp, STMF_PROVIDER_DATA_UPDATED, ppd->ppd_nv, cb_flags);
2393 2393 mutex_enter(&stmf_state.stmf_lock);
2394 2394 ipp->ipp_cb_in_progress = 0;
2395 2395
2396 2396 rpp_bail_out:
2397 2397 mutex_exit(&stmf_state.stmf_lock);
2398 2398
2399 2399 return (STMF_SUCCESS);
2400 2400 }
2401 2401
2402 2402 stmf_status_t
2403 2403 stmf_deregister_port_provider(stmf_port_provider_t *pp)
2404 2404 {
2405 2405 stmf_i_port_provider_t *ipp =
2406 2406 (stmf_i_port_provider_t *)pp->pp_stmf_private;
2407 2407 stmf_i_port_provider_t **ppipp;
2408 2408
2409 2409 mutex_enter(&stmf_state.stmf_lock);
2410 2410 if (ipp->ipp_npps || ipp->ipp_cb_in_progress) {
2411 2411 mutex_exit(&stmf_state.stmf_lock);
2412 2412 return (STMF_BUSY);
2413 2413 }
2414 2414 for (ppipp = &stmf_state.stmf_ipplist; *ppipp != NULL;
2415 2415 ppipp = &((*ppipp)->ipp_next)) {
2416 2416 if (*ppipp == ipp) {
2417 2417 *ppipp = ipp->ipp_next;
2418 2418 stmf_state.stmf_npps--;
2419 2419 if (ipp->ipp_ppd) {
2420 2420 ipp->ipp_ppd->ppd_provider = NULL;
2421 2421 ipp->ipp_ppd = NULL;
2422 2422 }
2423 2423 mutex_exit(&stmf_state.stmf_lock);
2424 2424 return (STMF_SUCCESS);
2425 2425 }
2426 2426 }
2427 2427 mutex_exit(&stmf_state.stmf_lock);
2428 2428 return (STMF_NOT_FOUND);
2429 2429 }
2430 2430
2431 2431 int
2432 2432 stmf_load_ppd_ioctl(stmf_ppioctl_data_t *ppi, uint64_t *ppi_token,
2433 2433 uint32_t *err_ret)
2434 2434 {
2435 2435 stmf_i_port_provider_t *ipp;
2436 2436 stmf_i_lu_provider_t *ilp;
2437 2437 stmf_pp_data_t *ppd;
2438 2438 nvlist_t *nv;
2439 2439 int s;
2440 2440 int ret;
2441 2441
2442 2442 *err_ret = 0;
2443 2443
2444 2444 if ((ppi->ppi_lu_provider + ppi->ppi_port_provider) != 1) {
2445 2445 return (EINVAL);
2446 2446 }
2447 2447
2448 2448 mutex_enter(&stmf_state.stmf_lock);
2449 2449 for (ppd = stmf_state.stmf_ppdlist; ppd != NULL; ppd = ppd->ppd_next) {
2450 2450 if (ppi->ppi_lu_provider) {
2451 2451 if (!ppd->ppd_lu_provider)
2452 2452 continue;
2453 2453 } else if (ppi->ppi_port_provider) {
2454 2454 if (!ppd->ppd_port_provider)
2455 2455 continue;
2456 2456 }
2457 2457 if (strncmp(ppi->ppi_name, ppd->ppd_name, 254) == 0)
2458 2458 break;
2459 2459 }
2460 2460
2461 2461 if (ppd == NULL) {
2462 2462 /* New provider */
2463 2463 s = strlen(ppi->ppi_name);
2464 2464 if (s > 254) {
2465 2465 mutex_exit(&stmf_state.stmf_lock);
2466 2466 return (EINVAL);
2467 2467 }
2468 2468 s += sizeof (stmf_pp_data_t) - 7;
2469 2469
2470 2470 ppd = kmem_zalloc(s, KM_NOSLEEP);
2471 2471 if (ppd == NULL) {
2472 2472 mutex_exit(&stmf_state.stmf_lock);
2473 2473 return (ENOMEM);
2474 2474 }
2475 2475 ppd->ppd_alloc_size = s;
2476 2476 (void) strcpy(ppd->ppd_name, ppi->ppi_name);
2477 2477
2478 2478 /* See if this provider already exists */
2479 2479 if (ppi->ppi_lu_provider) {
2480 2480 ppd->ppd_lu_provider = 1;
2481 2481 for (ilp = stmf_state.stmf_ilplist; ilp != NULL;
2482 2482 ilp = ilp->ilp_next) {
2483 2483 if (strcmp(ppi->ppi_name,
2484 2484 ilp->ilp_lp->lp_name) == 0) {
2485 2485 ppd->ppd_provider = ilp;
2486 2486 ilp->ilp_ppd = ppd;
2487 2487 break;
2488 2488 }
2489 2489 }
2490 2490 } else {
2491 2491 ppd->ppd_port_provider = 1;
2492 2492 for (ipp = stmf_state.stmf_ipplist; ipp != NULL;
2493 2493 ipp = ipp->ipp_next) {
2494 2494 if (strcmp(ppi->ppi_name,
2495 2495 ipp->ipp_pp->pp_name) == 0) {
2496 2496 ppd->ppd_provider = ipp;
2497 2497 ipp->ipp_ppd = ppd;
2498 2498 break;
2499 2499 }
2500 2500 }
2501 2501 }
2502 2502
2503 2503 /* Link this ppd in */
2504 2504 ppd->ppd_next = stmf_state.stmf_ppdlist;
2505 2505 stmf_state.stmf_ppdlist = ppd;
2506 2506 }
2507 2507
2508 2508 /*
2509 2509 * User is requesting that the token be checked.
2510 2510 * If there was another set after the user's get
2511 2511 * it's an error
2512 2512 */
2513 2513 if (ppi->ppi_token_valid) {
2514 2514 if (ppi->ppi_token != ppd->ppd_token) {
2515 2515 *err_ret = STMF_IOCERR_PPD_UPDATED;
2516 2516 mutex_exit(&stmf_state.stmf_lock);
2517 2517 return (EINVAL);
2518 2518 }
2519 2519 }
2520 2520
2521 2521 if ((ret = nvlist_unpack((char *)ppi->ppi_data,
2522 2522 (size_t)ppi->ppi_data_size, &nv, KM_NOSLEEP)) != 0) {
2523 2523 mutex_exit(&stmf_state.stmf_lock);
2524 2524 return (ret);
2525 2525 }
2526 2526
2527 2527 /* Free any existing lists and add this one to the ppd */
2528 2528 if (ppd->ppd_nv)
2529 2529 nvlist_free(ppd->ppd_nv);
2530 2530 ppd->ppd_nv = nv;
2531 2531
2532 2532 /* set the token for writes */
2533 2533 ppd->ppd_token++;
2534 2534 /* return token to caller */
2535 2535 if (ppi_token) {
2536 2536 *ppi_token = ppd->ppd_token;
2537 2537 }
2538 2538
2539 2539 /* If there is a provider registered, do the notifications */
2540 2540 if (ppd->ppd_provider) {
2541 2541 uint32_t cb_flags = 0;
2542 2542
2543 2543 if (stmf_state.stmf_config_state == STMF_CONFIG_INIT)
2544 2544 cb_flags |= STMF_PCB_STMF_ONLINING;
2545 2545 if (ppi->ppi_lu_provider) {
2546 2546 ilp = (stmf_i_lu_provider_t *)ppd->ppd_provider;
2547 2547 if (ilp->ilp_lp->lp_cb == NULL)
2548 2548 goto bail_out;
2549 2549 ilp->ilp_cb_in_progress = 1;
2550 2550 mutex_exit(&stmf_state.stmf_lock);
2551 2551 ilp->ilp_lp->lp_cb(ilp->ilp_lp,
2552 2552 STMF_PROVIDER_DATA_UPDATED, ppd->ppd_nv, cb_flags);
2553 2553 mutex_enter(&stmf_state.stmf_lock);
2554 2554 ilp->ilp_cb_in_progress = 0;
2555 2555 } else {
2556 2556 ipp = (stmf_i_port_provider_t *)ppd->ppd_provider;
2557 2557 if (ipp->ipp_pp->pp_cb == NULL)
2558 2558 goto bail_out;
2559 2559 ipp->ipp_cb_in_progress = 1;
2560 2560 mutex_exit(&stmf_state.stmf_lock);
2561 2561 ipp->ipp_pp->pp_cb(ipp->ipp_pp,
2562 2562 STMF_PROVIDER_DATA_UPDATED, ppd->ppd_nv, cb_flags);
2563 2563 mutex_enter(&stmf_state.stmf_lock);
2564 2564 ipp->ipp_cb_in_progress = 0;
2565 2565 }
2566 2566 }
2567 2567
2568 2568 bail_out:
2569 2569 mutex_exit(&stmf_state.stmf_lock);
2570 2570
2571 2571 return (0);
2572 2572 }
2573 2573
2574 2574 void
2575 2575 stmf_delete_ppd(stmf_pp_data_t *ppd)
2576 2576 {
2577 2577 stmf_pp_data_t **pppd;
2578 2578
2579 2579 ASSERT(mutex_owned(&stmf_state.stmf_lock));
2580 2580 if (ppd->ppd_provider) {
2581 2581 if (ppd->ppd_lu_provider) {
2582 2582 ((stmf_i_lu_provider_t *)
2583 2583 ppd->ppd_provider)->ilp_ppd = NULL;
2584 2584 } else {
2585 2585 ((stmf_i_port_provider_t *)
2586 2586 ppd->ppd_provider)->ipp_ppd = NULL;
2587 2587 }
2588 2588 ppd->ppd_provider = NULL;
2589 2589 }
2590 2590
2591 2591 for (pppd = &stmf_state.stmf_ppdlist; *pppd != NULL;
2592 2592 pppd = &((*pppd)->ppd_next)) {
2593 2593 if (*pppd == ppd)
2594 2594 break;
2595 2595 }
2596 2596
2597 2597 if (*pppd == NULL)
2598 2598 return;
2599 2599
2600 2600 *pppd = ppd->ppd_next;
2601 2601 if (ppd->ppd_nv)
2602 2602 nvlist_free(ppd->ppd_nv);
2603 2603
2604 2604 kmem_free(ppd, ppd->ppd_alloc_size);
2605 2605 }
2606 2606
2607 2607 int
2608 2608 stmf_delete_ppd_ioctl(stmf_ppioctl_data_t *ppi)
2609 2609 {
2610 2610 stmf_pp_data_t *ppd;
2611 2611 int ret = ENOENT;
2612 2612
2613 2613 if ((ppi->ppi_lu_provider + ppi->ppi_port_provider) != 1) {
2614 2614 return (EINVAL);
2615 2615 }
2616 2616
2617 2617 mutex_enter(&stmf_state.stmf_lock);
2618 2618
2619 2619 for (ppd = stmf_state.stmf_ppdlist; ppd != NULL; ppd = ppd->ppd_next) {
2620 2620 if (ppi->ppi_lu_provider) {
2621 2621 if (!ppd->ppd_lu_provider)
2622 2622 continue;
2623 2623 } else if (ppi->ppi_port_provider) {
2624 2624 if (!ppd->ppd_port_provider)
2625 2625 continue;
2626 2626 }
2627 2627 if (strncmp(ppi->ppi_name, ppd->ppd_name, 254) == 0)
2628 2628 break;
2629 2629 }
2630 2630
2631 2631 if (ppd) {
2632 2632 ret = 0;
2633 2633 stmf_delete_ppd(ppd);
2634 2634 }
2635 2635 mutex_exit(&stmf_state.stmf_lock);
2636 2636
2637 2637 return (ret);
2638 2638 }
2639 2639
2640 2640 int
2641 2641 stmf_get_ppd_ioctl(stmf_ppioctl_data_t *ppi, stmf_ppioctl_data_t *ppi_out,
2642 2642 uint32_t *err_ret)
2643 2643 {
2644 2644 stmf_pp_data_t *ppd;
2645 2645 size_t req_size;
2646 2646 int ret = ENOENT;
2647 2647 char *bufp = (char *)ppi_out->ppi_data;
2648 2648
2649 2649 if ((ppi->ppi_lu_provider + ppi->ppi_port_provider) != 1) {
2650 2650 return (EINVAL);
2651 2651 }
2652 2652
2653 2653 mutex_enter(&stmf_state.stmf_lock);
2654 2654
2655 2655 for (ppd = stmf_state.stmf_ppdlist; ppd != NULL; ppd = ppd->ppd_next) {
2656 2656 if (ppi->ppi_lu_provider) {
2657 2657 if (!ppd->ppd_lu_provider)
2658 2658 continue;
2659 2659 } else if (ppi->ppi_port_provider) {
2660 2660 if (!ppd->ppd_port_provider)
2661 2661 continue;
2662 2662 }
2663 2663 if (strncmp(ppi->ppi_name, ppd->ppd_name, 254) == 0)
2664 2664 break;
2665 2665 }
2666 2666
2667 2667 if (ppd && ppd->ppd_nv) {
2668 2668 ppi_out->ppi_token = ppd->ppd_token;
2669 2669 if ((ret = nvlist_size(ppd->ppd_nv, &req_size,
2670 2670 NV_ENCODE_XDR)) != 0) {
2671 2671 goto done;
2672 2672 }
2673 2673 ppi_out->ppi_data_size = req_size;
2674 2674 if (req_size > ppi->ppi_data_size) {
2675 2675 *err_ret = STMF_IOCERR_INSUFFICIENT_BUF;
2676 2676 ret = EINVAL;
2677 2677 goto done;
2678 2678 }
2679 2679
2680 2680 if ((ret = nvlist_pack(ppd->ppd_nv, &bufp, &req_size,
2681 2681 NV_ENCODE_XDR, 0)) != 0) {
2682 2682 goto done;
2683 2683 }
2684 2684 ret = 0;
2685 2685 }
2686 2686
2687 2687 done:
2688 2688 mutex_exit(&stmf_state.stmf_lock);
2689 2689
2690 2690 return (ret);
2691 2691 }
2692 2692
2693 2693 void
2694 2694 stmf_delete_all_ppds()
2695 2695 {
2696 2696 stmf_pp_data_t *ppd, *nppd;
2697 2697
2698 2698 ASSERT(mutex_owned(&stmf_state.stmf_lock));
2699 2699 for (ppd = stmf_state.stmf_ppdlist; ppd != NULL; ppd = nppd) {
2700 2700 nppd = ppd->ppd_next;
2701 2701 stmf_delete_ppd(ppd);
2702 2702 }
2703 2703 }
2704 2704
2705 2705 /*
2706 2706 * 16 is the max string length of a protocol_ident, increase
2707 2707 * the size if needed.
2708 2708 */
2709 2709 #define STMF_KSTAT_LU_SZ (STMF_GUID_INPUT + 1 + 256)
2710 2710 #define STMF_KSTAT_TGT_SZ (256 * 2 + 16)
2711 2711
2712 2712 /*
2713 2713 * This array matches the Protocol Identifier in stmf_ioctl.h
2714 2714 */
2715 2715 #define MAX_PROTO_STR_LEN 32
2716 2716
2717 2717 char *protocol_ident[PROTOCOL_ANY] = {
2718 2718 "Fibre Channel",
2719 2719 "Parallel SCSI",
2720 2720 "SSA",
2721 2721 "IEEE_1394",
2722 2722 "SRP",
2723 2723 "iSCSI",
2724 2724 "SAS",
2725 2725 "ADT",
2726 2726 "ATAPI",
2727 2727 "UNKNOWN", "UNKNOWN", "UNKNOWN", "UNKNOWN", "UNKNOWN", "UNKNOWN"
2728 2728 };
2729 2729
2730 2730 /*
2731 2731 * Update the lun wait/run queue count
2732 2732 */
2733 2733 static void
2734 2734 stmf_update_kstat_lu_q(scsi_task_t *task, void func())
2735 2735 {
2736 2736 stmf_i_lu_t *ilu;
2737 2737 kstat_io_t *kip;
2738 2738
2739 2739 if (task->task_lu == dlun0)
2740 2740 return;
2741 2741 ilu = (stmf_i_lu_t *)task->task_lu->lu_stmf_private;
2742 2742 if (ilu != NULL && ilu->ilu_kstat_io != NULL) {
2743 2743 kip = KSTAT_IO_PTR(ilu->ilu_kstat_io);
2744 2744 if (kip != NULL) {
2745 2745 func(kip);
2746 2746 }
2747 2747 }
2748 2748 }
2749 2749
2750 2750 /*
2751 2751 * Update the target(lport) wait/run queue count
2752 2752 */
2753 2753 static void
2754 2754 stmf_update_kstat_lport_q(scsi_task_t *task, void func())
2755 2755 {
2756 2756 stmf_i_local_port_t *ilp;
2757 2757 kstat_io_t *kip;
2758 2758
2759 2759 ilp = (stmf_i_local_port_t *)task->task_lport->lport_stmf_private;
2760 2760 if (ilp != NULL && ilp->ilport_kstat_io != NULL) {
2761 2761 kip = KSTAT_IO_PTR(ilp->ilport_kstat_io);
2762 2762 if (kip != NULL) {
2763 2763 mutex_enter(ilp->ilport_kstat_io->ks_lock);
2764 2764 func(kip);
2765 2765 mutex_exit(ilp->ilport_kstat_io->ks_lock);
2766 2766 }
2767 2767 }
2768 2768 }
2769 2769
2770 2770 static void
2771 2771 stmf_update_kstat_lport_io(scsi_task_t *task, stmf_data_buf_t *dbuf)
2772 2772 {
2773 2773 stmf_i_local_port_t *ilp;
2774 2774 kstat_io_t *kip;
2775 2775
2776 2776 ilp = (stmf_i_local_port_t *)task->task_lport->lport_stmf_private;
2777 2777 if (ilp != NULL && ilp->ilport_kstat_io != NULL) {
2778 2778 kip = KSTAT_IO_PTR(ilp->ilport_kstat_io);
2779 2779 if (kip != NULL) {
2780 2780 mutex_enter(ilp->ilport_kstat_io->ks_lock);
2781 2781 STMF_UPDATE_KSTAT_IO(kip, dbuf);
2782 2782 mutex_exit(ilp->ilport_kstat_io->ks_lock);
2783 2783 }
2784 2784 }
2785 2785 }
2786 2786
2787 2787 static void
2788 2788 stmf_update_kstat_lu_io(scsi_task_t *task, stmf_data_buf_t *dbuf)
2789 2789 {
2790 2790 stmf_i_lu_t *ilu;
2791 2791 kstat_io_t *kip;
2792 2792
2793 2793 ilu = (stmf_i_lu_t *)task->task_lu->lu_stmf_private;
2794 2794 if (ilu != NULL && ilu->ilu_kstat_io != NULL) {
2795 2795 kip = KSTAT_IO_PTR(ilu->ilu_kstat_io);
2796 2796 if (kip != NULL) {
2797 2797 mutex_enter(ilu->ilu_kstat_io->ks_lock);
2798 2798 STMF_UPDATE_KSTAT_IO(kip, dbuf);
2799 2799 mutex_exit(ilu->ilu_kstat_io->ks_lock);
2800 2800 }
2801 2801 }
2802 2802 }
2803 2803
2804 2804 static void
2805 2805 stmf_create_kstat_lu(stmf_i_lu_t *ilu)
2806 2806 {
2807 2807 char ks_nm[KSTAT_STRLEN];
2808 2808 stmf_kstat_lu_info_t *ks_lu;
2809 2809
2810 2810 /* create kstat lun info */
2811 2811 ks_lu = (stmf_kstat_lu_info_t *)kmem_zalloc(STMF_KSTAT_LU_SZ,
2812 2812 KM_NOSLEEP);
2813 2813 if (ks_lu == NULL) {
2814 2814 cmn_err(CE_WARN, "STMF: kmem_zalloc failed");
2815 2815 return;
2816 2816 }
2817 2817
2818 2818 bzero(ks_nm, sizeof (ks_nm));
2819 2819 (void) sprintf(ks_nm, "stmf_lu_%"PRIxPTR"", (uintptr_t)ilu);
2820 2820 if ((ilu->ilu_kstat_info = kstat_create(STMF_MODULE_NAME, 0,
2821 2821 ks_nm, "misc", KSTAT_TYPE_NAMED,
2822 2822 sizeof (stmf_kstat_lu_info_t) / sizeof (kstat_named_t),
2823 2823 KSTAT_FLAG_VIRTUAL)) == NULL) {
2824 2824 kmem_free(ks_lu, STMF_KSTAT_LU_SZ);
2825 2825 cmn_err(CE_WARN, "STMF: kstat_create lu failed");
2826 2826 return;
2827 2827 }
2828 2828
2829 2829 ilu->ilu_kstat_info->ks_data_size = STMF_KSTAT_LU_SZ;
2830 2830 ilu->ilu_kstat_info->ks_data = ks_lu;
2831 2831
2832 2832 kstat_named_init(&ks_lu->i_lun_guid, "lun-guid",
2833 2833 KSTAT_DATA_STRING);
2834 2834 kstat_named_init(&ks_lu->i_lun_alias, "lun-alias",
2835 2835 KSTAT_DATA_STRING);
2836 2836
2837 2837 /* convert guid to hex string */
2838 2838 int i;
2839 2839 uint8_t *p = ilu->ilu_lu->lu_id->ident;
2840 2840 bzero(ilu->ilu_ascii_hex_guid, sizeof (ilu->ilu_ascii_hex_guid));
2841 2841 for (i = 0; i < STMF_GUID_INPUT / 2; i++) {
2842 2842 (void) sprintf(&ilu->ilu_ascii_hex_guid[i * 2], "%02x", p[i]);
2843 2843 }
2844 2844 kstat_named_setstr(&ks_lu->i_lun_guid,
2845 2845 (const char *)ilu->ilu_ascii_hex_guid);
2846 2846 kstat_named_setstr(&ks_lu->i_lun_alias,
2847 2847 (const char *)ilu->ilu_lu->lu_alias);
2848 2848 kstat_install(ilu->ilu_kstat_info);
2849 2849
2850 2850 /* create kstat lun io */
2851 2851 bzero(ks_nm, sizeof (ks_nm));
2852 2852 (void) sprintf(ks_nm, "stmf_lu_io_%"PRIxPTR"", (uintptr_t)ilu);
2853 2853 if ((ilu->ilu_kstat_io = kstat_create(STMF_MODULE_NAME, 0,
2854 2854 ks_nm, "io", KSTAT_TYPE_IO, 1, 0)) == NULL) {
2855 2855 cmn_err(CE_WARN, "STMF: kstat_create lu_io failed");
2856 2856 return;
2857 2857 }
2858 2858 mutex_init(&ilu->ilu_kstat_lock, NULL, MUTEX_DRIVER, 0);
2859 2859 ilu->ilu_kstat_io->ks_lock = &ilu->ilu_kstat_lock;
2860 2860 kstat_install(ilu->ilu_kstat_io);
2861 2861 }
2862 2862
2863 2863 static void
2864 2864 stmf_create_kstat_lport(stmf_i_local_port_t *ilport)
2865 2865 {
2866 2866 char ks_nm[KSTAT_STRLEN];
2867 2867 stmf_kstat_tgt_info_t *ks_tgt;
2868 2868 int id, len;
2869 2869
2870 2870 /* create kstat lport info */
2871 2871 ks_tgt = (stmf_kstat_tgt_info_t *)kmem_zalloc(STMF_KSTAT_TGT_SZ,
2872 2872 KM_NOSLEEP);
2873 2873 if (ks_tgt == NULL) {
2874 2874 cmn_err(CE_WARN, "STMF: kmem_zalloc failed");
2875 2875 return;
2876 2876 }
2877 2877
2878 2878 bzero(ks_nm, sizeof (ks_nm));
2879 2879 (void) sprintf(ks_nm, "stmf_tgt_%"PRIxPTR"", (uintptr_t)ilport);
2880 2880 if ((ilport->ilport_kstat_info = kstat_create(STMF_MODULE_NAME,
2881 2881 0, ks_nm, "misc", KSTAT_TYPE_NAMED,
2882 2882 sizeof (stmf_kstat_tgt_info_t) / sizeof (kstat_named_t),
2883 2883 KSTAT_FLAG_VIRTUAL)) == NULL) {
2884 2884 kmem_free(ks_tgt, STMF_KSTAT_TGT_SZ);
2885 2885 cmn_err(CE_WARN, "STMF: kstat_create target failed");
2886 2886 return;
2887 2887 }
2888 2888
2889 2889 ilport->ilport_kstat_info->ks_data_size = STMF_KSTAT_TGT_SZ;
2890 2890 ilport->ilport_kstat_info->ks_data = ks_tgt;
2891 2891
2892 2892 kstat_named_init(&ks_tgt->i_tgt_name, "target-name",
2893 2893 KSTAT_DATA_STRING);
2894 2894 kstat_named_init(&ks_tgt->i_tgt_alias, "target-alias",
2895 2895 KSTAT_DATA_STRING);
2896 2896 kstat_named_init(&ks_tgt->i_protocol, "protocol",
2897 2897 KSTAT_DATA_STRING);
2898 2898
2899 2899 /* ident might not be null terminated */
2900 2900 len = ilport->ilport_lport->lport_id->ident_length;
2901 2901 bcopy(ilport->ilport_lport->lport_id->ident,
2902 2902 ilport->ilport_kstat_tgt_name, len);
2903 2903 ilport->ilport_kstat_tgt_name[len + 1] = NULL;
2904 2904 kstat_named_setstr(&ks_tgt->i_tgt_name,
2905 2905 (const char *)ilport->ilport_kstat_tgt_name);
2906 2906 kstat_named_setstr(&ks_tgt->i_tgt_alias,
2907 2907 (const char *)ilport->ilport_lport->lport_alias);
2908 2908 /* protocol */
2909 2909 if ((id = ilport->ilport_lport->lport_id->protocol_id) > PROTOCOL_ANY) {
2910 2910 cmn_err(CE_WARN, "STMF: protocol_id out of bound");
2911 2911 id = PROTOCOL_ANY;
2912 2912 }
2913 2913 kstat_named_setstr(&ks_tgt->i_protocol, protocol_ident[id]);
2914 2914 kstat_install(ilport->ilport_kstat_info);
2915 2915
2916 2916 /* create kstat lport io */
2917 2917 bzero(ks_nm, sizeof (ks_nm));
2918 2918 (void) sprintf(ks_nm, "stmf_tgt_io_%"PRIxPTR"", (uintptr_t)ilport);
2919 2919 if ((ilport->ilport_kstat_io = kstat_create(STMF_MODULE_NAME, 0,
2920 2920 ks_nm, "io", KSTAT_TYPE_IO, 1, 0)) == NULL) {
2921 2921 cmn_err(CE_WARN, "STMF: kstat_create target_io failed");
2922 2922 return;
2923 2923 }
2924 2924 mutex_init(&ilport->ilport_kstat_lock, NULL, MUTEX_DRIVER, 0);
2925 2925 ilport->ilport_kstat_io->ks_lock = &ilport->ilport_kstat_lock;
2926 2926 kstat_install(ilport->ilport_kstat_io);
2927 2927 }
2928 2928
2929 2929 /*
2930 2930 * set the asymmetric access state for a logical unit
2931 2931 * caller is responsible for establishing SCSI unit attention on
2932 2932 * state change
2933 2933 */
2934 2934 stmf_status_t
2935 2935 stmf_set_lu_access(stmf_lu_t *lu, uint8_t access_state)
2936 2936 {
2937 2937 stmf_i_lu_t *ilu;
2938 2938 uint8_t *p1, *p2;
2939 2939
2940 2940 if ((access_state != STMF_LU_STANDBY) &&
2941 2941 (access_state != STMF_LU_ACTIVE)) {
2942 2942 return (STMF_INVALID_ARG);
2943 2943 }
2944 2944
2945 2945 p1 = &lu->lu_id->ident[0];
2946 2946 mutex_enter(&stmf_state.stmf_lock);
2947 2947 if (stmf_state.stmf_inventory_locked) {
2948 2948 mutex_exit(&stmf_state.stmf_lock);
2949 2949 return (STMF_BUSY);
2950 2950 }
2951 2951
2952 2952 for (ilu = stmf_state.stmf_ilulist; ilu != NULL; ilu = ilu->ilu_next) {
2953 2953 p2 = &ilu->ilu_lu->lu_id->ident[0];
2954 2954 if (bcmp(p1, p2, 16) == 0) {
2955 2955 break;
2956 2956 }
2957 2957 }
2958 2958
2959 2959 if (!ilu) {
2960 2960 ilu = (stmf_i_lu_t *)lu->lu_stmf_private;
2961 2961 } else {
2962 2962 /*
2963 2963 * We're changing access state on an existing logical unit
2964 2964 * Send the proxy registration message for this logical unit
2965 2965 * if we're in alua mode.
2966 2966 * If the requested state is STMF_LU_ACTIVE, we want to register
2967 2967 * this logical unit.
2968 2968 * If the requested state is STMF_LU_STANDBY, we're going to
2969 2969 * abort all tasks for this logical unit.
2970 2970 */
2971 2971 if (stmf_state.stmf_alua_state == 1 &&
2972 2972 access_state == STMF_LU_ACTIVE) {
2973 2973 stmf_ic_msg_status_t ic_ret = STMF_IC_MSG_SUCCESS;
2974 2974 stmf_ic_msg_t *ic_reg_lun;
2975 2975 if (lu->lu_lp && lu->lu_lp->lp_lpif_rev == LPIF_REV_2 &&
2976 2976 lu->lu_lp->lp_alua_support) {
2977 2977 ilu->ilu_alua = 1;
2978 2978 /* allocate the register message */
2979 2979 ic_reg_lun = ic_lun_active_msg_alloc(p1,
2980 2980 lu->lu_lp->lp_name,
2981 2981 lu->lu_proxy_reg_arg_len,
2982 2982 (uint8_t *)lu->lu_proxy_reg_arg,
2983 2983 stmf_proxy_msg_id);
2984 2984 /* send the message */
2985 2985 if (ic_reg_lun) {
2986 2986 ic_ret = ic_tx_msg(ic_reg_lun);
2987 2987 if (ic_ret == STMF_IC_MSG_SUCCESS) {
2988 2988 stmf_proxy_msg_id++;
2989 2989 }
2990 2990 }
2991 2991 }
2992 2992 } else if (stmf_state.stmf_alua_state == 1 &&
2993 2993 access_state == STMF_LU_STANDBY) {
2994 2994 /* abort all tasks for this lu */
2995 2995 stmf_task_lu_killall(lu, NULL, STMF_ABORTED);
2996 2996 }
2997 2997 }
2998 2998
2999 2999 ilu->ilu_access = access_state;
3000 3000
3001 3001 mutex_exit(&stmf_state.stmf_lock);
3002 3002 return (STMF_SUCCESS);
3003 3003 }
3004 3004
3005 3005
3006 3006 stmf_status_t
3007 3007 stmf_register_lu(stmf_lu_t *lu)
3008 3008 {
3009 3009 stmf_i_lu_t *ilu;
3010 3010 uint8_t *p1, *p2;
3011 3011 stmf_state_change_info_t ssci;
3012 3012 stmf_id_data_t *luid;
3013 3013
3014 3014 if ((lu->lu_id->ident_type != ID_TYPE_NAA) ||
3015 3015 (lu->lu_id->ident_length != 16) ||
3016 3016 ((lu->lu_id->ident[0] & 0xf0) != 0x60)) {
3017 3017 return (STMF_INVALID_ARG);
3018 3018 }
3019 3019 p1 = &lu->lu_id->ident[0];
3020 3020 mutex_enter(&stmf_state.stmf_lock);
3021 3021 if (stmf_state.stmf_inventory_locked) {
3022 3022 mutex_exit(&stmf_state.stmf_lock);
3023 3023 return (STMF_BUSY);
3024 3024 }
3025 3025
3026 3026 for (ilu = stmf_state.stmf_ilulist; ilu != NULL; ilu = ilu->ilu_next) {
3027 3027 p2 = &ilu->ilu_lu->lu_id->ident[0];
3028 3028 if (bcmp(p1, p2, 16) == 0) {
3029 3029 mutex_exit(&stmf_state.stmf_lock);
3030 3030 return (STMF_ALREADY);
3031 3031 }
3032 3032 }
3033 3033
3034 3034 ilu = (stmf_i_lu_t *)lu->lu_stmf_private;
3035 3035 luid = stmf_lookup_id(&stmf_state.stmf_luid_list,
3036 3036 lu->lu_id->ident_length, lu->lu_id->ident);
3037 3037 if (luid) {
3038 3038 luid->id_pt_to_object = (void *)ilu;
3039 3039 ilu->ilu_luid = luid;
3040 3040 }
3041 3041 ilu->ilu_alias = NULL;
3042 3042
3043 3043 ilu->ilu_next = stmf_state.stmf_ilulist;
3044 3044 ilu->ilu_prev = NULL;
3045 3045 if (ilu->ilu_next)
3046 3046 ilu->ilu_next->ilu_prev = ilu;
3047 3047 stmf_state.stmf_ilulist = ilu;
3048 3048 stmf_state.stmf_nlus++;
3049 3049 if (lu->lu_lp) {
3050 3050 ((stmf_i_lu_provider_t *)
3051 3051 (lu->lu_lp->lp_stmf_private))->ilp_nlus++;
3052 3052 }
3053 3053 ilu->ilu_cur_task_cntr = &ilu->ilu_task_cntr1;
3054 3054 STMF_EVENT_ALLOC_HANDLE(ilu->ilu_event_hdl);
3055 3055 cv_init(&ilu->ilu_offline_pending_cv, NULL, CV_DRIVER, NULL);
3056 3056 stmf_create_kstat_lu(ilu);
3057 3057 /*
3058 3058 * register with proxy module if available and logical unit
3059 3059 * is in active state
3060 3060 */
3061 3061 if (stmf_state.stmf_alua_state == 1 &&
3062 3062 ilu->ilu_access == STMF_LU_ACTIVE) {
3063 3063 stmf_ic_msg_status_t ic_ret = STMF_IC_MSG_SUCCESS;
3064 3064 stmf_ic_msg_t *ic_reg_lun;
3065 3065 if (lu->lu_lp && lu->lu_lp->lp_lpif_rev == LPIF_REV_2 &&
3066 3066 lu->lu_lp->lp_alua_support) {
3067 3067 ilu->ilu_alua = 1;
3068 3068 /* allocate the register message */
3069 3069 ic_reg_lun = ic_reg_lun_msg_alloc(p1,
3070 3070 lu->lu_lp->lp_name, lu->lu_proxy_reg_arg_len,
3071 3071 (uint8_t *)lu->lu_proxy_reg_arg, stmf_proxy_msg_id);
3072 3072 /* send the message */
3073 3073 if (ic_reg_lun) {
3074 3074 ic_ret = ic_tx_msg(ic_reg_lun);
3075 3075 if (ic_ret == STMF_IC_MSG_SUCCESS) {
3076 3076 stmf_proxy_msg_id++;
3077 3077 }
3078 3078 }
3079 3079 }
3080 3080 }
3081 3081 mutex_exit(&stmf_state.stmf_lock);
3082 3082
3083 3083 /* check the default state for lu */
3084 3084 if (stmf_state.stmf_default_lu_state == STMF_STATE_OFFLINE) {
3085 3085 ilu->ilu_prev_state = STMF_STATE_OFFLINE;
3086 3086 } else {
3087 3087 ilu->ilu_prev_state = STMF_STATE_ONLINE;
3088 3088 if (stmf_state.stmf_service_running) {
3089 3089 ssci.st_rflags = 0;
3090 3090 ssci.st_additional_info = NULL;
3091 3091 (void) stmf_ctl(STMF_CMD_LU_ONLINE, lu, &ssci);
3092 3092 }
3093 3093 }
3094 3094
3095 3095 /* XXX: Generate event */
3096 3096 return (STMF_SUCCESS);
3097 3097 }
3098 3098
3099 3099 stmf_status_t
3100 3100 stmf_deregister_lu(stmf_lu_t *lu)
3101 3101 {
3102 3102 stmf_i_lu_t *ilu;
3103 3103
3104 3104 mutex_enter(&stmf_state.stmf_lock);
3105 3105 if (stmf_state.stmf_inventory_locked) {
3106 3106 mutex_exit(&stmf_state.stmf_lock);
3107 3107 return (STMF_BUSY);
3108 3108 }
3109 3109 ilu = stmf_lookup_lu(lu);
3110 3110 if (ilu == NULL) {
3111 3111 mutex_exit(&stmf_state.stmf_lock);
3112 3112 return (STMF_INVALID_ARG);
3113 3113 }
3114 3114 if (ilu->ilu_state == STMF_STATE_OFFLINE) {
3115 3115 ASSERT(ilu->ilu_ntasks == ilu->ilu_ntasks_free);
3116 3116 while (ilu->ilu_flags & ILU_STALL_DEREGISTER) {
3117 3117 cv_wait(&stmf_state.stmf_cv, &stmf_state.stmf_lock);
3118 3118 }
3119 3119 if (ilu->ilu_ntasks) {
3120 3120 stmf_i_scsi_task_t *itask, *nitask;
3121 3121
3122 3122 nitask = ilu->ilu_tasks;
3123 3123 do {
3124 3124 itask = nitask;
3125 3125 nitask = itask->itask_lu_next;
3126 3126 lu->lu_task_free(itask->itask_task);
3127 3127 stmf_free(itask->itask_task);
3128 3128 } while (nitask != NULL);
3129 3129
3130 3130 ilu->ilu_tasks = ilu->ilu_free_tasks = NULL;
3131 3131 ilu->ilu_ntasks = ilu->ilu_ntasks_free = 0;
3132 3132 }
3133 3133 /* de-register with proxy if available */
3134 3134 if (ilu->ilu_access == STMF_LU_ACTIVE &&
3135 3135 stmf_state.stmf_alua_state == 1) {
3136 3136 /* de-register with proxy module */
3137 3137 stmf_ic_msg_status_t ic_ret = STMF_IC_MSG_SUCCESS;
3138 3138 stmf_ic_msg_t *ic_dereg_lun;
3139 3139 if (lu->lu_lp && lu->lu_lp->lp_lpif_rev == LPIF_REV_2 &&
3140 3140 lu->lu_lp->lp_alua_support) {
3141 3141 ilu->ilu_alua = 1;
3142 3142 /* allocate the de-register message */
3143 3143 ic_dereg_lun = ic_dereg_lun_msg_alloc(
3144 3144 lu->lu_id->ident, lu->lu_lp->lp_name, 0,
3145 3145 NULL, stmf_proxy_msg_id);
3146 3146 /* send the message */
3147 3147 if (ic_dereg_lun) {
3148 3148 ic_ret = ic_tx_msg(ic_dereg_lun);
3149 3149 if (ic_ret == STMF_IC_MSG_SUCCESS) {
3150 3150 stmf_proxy_msg_id++;
3151 3151 }
3152 3152 }
3153 3153 }
3154 3154 }
3155 3155
3156 3156 if (ilu->ilu_next)
3157 3157 ilu->ilu_next->ilu_prev = ilu->ilu_prev;
3158 3158 if (ilu->ilu_prev)
3159 3159 ilu->ilu_prev->ilu_next = ilu->ilu_next;
3160 3160 else
3161 3161 stmf_state.stmf_ilulist = ilu->ilu_next;
3162 3162 stmf_state.stmf_nlus--;
3163 3163
3164 3164 if (ilu == stmf_state.stmf_svc_ilu_draining) {
3165 3165 stmf_state.stmf_svc_ilu_draining = ilu->ilu_next;
3166 3166 }
3167 3167 if (ilu == stmf_state.stmf_svc_ilu_timing) {
3168 3168 stmf_state.stmf_svc_ilu_timing = ilu->ilu_next;
3169 3169 }
3170 3170 if (lu->lu_lp) {
3171 3171 ((stmf_i_lu_provider_t *)
3172 3172 (lu->lu_lp->lp_stmf_private))->ilp_nlus--;
3173 3173 }
3174 3174 if (ilu->ilu_luid) {
3175 3175 ((stmf_id_data_t *)ilu->ilu_luid)->id_pt_to_object =
3176 3176 NULL;
3177 3177 ilu->ilu_luid = NULL;
3178 3178 }
3179 3179 STMF_EVENT_FREE_HANDLE(ilu->ilu_event_hdl);
3180 3180 } else {
3181 3181 mutex_exit(&stmf_state.stmf_lock);
3182 3182 return (STMF_BUSY);
3183 3183 }
3184 3184 if (ilu->ilu_kstat_info) {
3185 3185 kmem_free(ilu->ilu_kstat_info->ks_data,
3186 3186 ilu->ilu_kstat_info->ks_data_size);
3187 3187 kstat_delete(ilu->ilu_kstat_info);
3188 3188 }
3189 3189 if (ilu->ilu_kstat_io) {
3190 3190 kstat_delete(ilu->ilu_kstat_io);
3191 3191 mutex_destroy(&ilu->ilu_kstat_lock);
3192 3192 }
3193 3193 cv_destroy(&ilu->ilu_offline_pending_cv);
3194 3194 mutex_exit(&stmf_state.stmf_lock);
3195 3195 return (STMF_SUCCESS);
3196 3196 }
3197 3197
3198 3198 void
3199 3199 stmf_set_port_standby(stmf_local_port_t *lport, uint16_t rtpid)
3200 3200 {
3201 3201 stmf_i_local_port_t *ilport =
3202 3202 (stmf_i_local_port_t *)lport->lport_stmf_private;
3203 3203 ilport->ilport_rtpid = rtpid;
3204 3204 ilport->ilport_standby = 1;
3205 3205 }
3206 3206
3207 3207 void
3208 3208 stmf_set_port_alua(stmf_local_port_t *lport)
3209 3209 {
3210 3210 stmf_i_local_port_t *ilport =
3211 3211 (stmf_i_local_port_t *)lport->lport_stmf_private;
3212 3212 ilport->ilport_alua = 1;
3213 3213 }
3214 3214
3215 3215 stmf_status_t
3216 3216 stmf_register_local_port(stmf_local_port_t *lport)
3217 3217 {
3218 3218 stmf_i_local_port_t *ilport;
3219 3219 stmf_state_change_info_t ssci;
3220 3220 int start_workers = 0;
3221 3221
3222 3222 mutex_enter(&stmf_state.stmf_lock);
3223 3223 if (stmf_state.stmf_inventory_locked) {
3224 3224 mutex_exit(&stmf_state.stmf_lock);
3225 3225 return (STMF_BUSY);
3226 3226 }
3227 3227 ilport = (stmf_i_local_port_t *)lport->lport_stmf_private;
3228 3228 rw_init(&ilport->ilport_lock, NULL, RW_DRIVER, NULL);
3229 3229
3230 3230 ilport->ilport_instance =
3231 3231 id_alloc_nosleep(stmf_state.stmf_ilport_inst_space);
3232 3232 if (ilport->ilport_instance == -1) {
3233 3233 mutex_exit(&stmf_state.stmf_lock);
3234 3234 return (STMF_FAILURE);
3235 3235 }
3236 3236 ilport->ilport_next = stmf_state.stmf_ilportlist;
3237 3237 ilport->ilport_prev = NULL;
3238 3238 if (ilport->ilport_next)
3239 3239 ilport->ilport_next->ilport_prev = ilport;
3240 3240 stmf_state.stmf_ilportlist = ilport;
3241 3241 stmf_state.stmf_nlports++;
3242 3242 if (lport->lport_pp) {
3243 3243 ((stmf_i_port_provider_t *)
3244 3244 (lport->lport_pp->pp_stmf_private))->ipp_npps++;
3245 3245 }
|
↓ open down ↓ |
1138 lines elided |
↑ open up ↑ |
3246 3246 ilport->ilport_tg =
3247 3247 stmf_lookup_group_for_target(lport->lport_id->ident,
3248 3248 lport->lport_id->ident_length);
3249 3249
3250 3250 /*
3251 3251 * rtpid will/must be set if this is a standby port
3252 3252 * only register ports that are not standby (proxy) ports
3253 3253 * and ports that are alua participants (ilport_alua == 1)
3254 3254 */
3255 3255 if (ilport->ilport_standby == 0) {
3256 - ilport->ilport_rtpid = atomic_add_16_nv(&stmf_rtpid_counter, 1);
3256 + ilport->ilport_rtpid = atomic_inc_16_nv(&stmf_rtpid_counter);
3257 3257 }
3258 3258
3259 3259 if (stmf_state.stmf_alua_state == 1 &&
3260 3260 ilport->ilport_standby == 0 &&
3261 3261 ilport->ilport_alua == 1) {
3262 3262 stmf_ic_msg_t *ic_reg_port;
3263 3263 stmf_ic_msg_status_t ic_ret;
3264 3264 stmf_local_port_t *lport;
3265 3265 lport = ilport->ilport_lport;
3266 3266 ic_reg_port = ic_reg_port_msg_alloc(
3267 3267 lport->lport_id, ilport->ilport_rtpid,
3268 3268 0, NULL, stmf_proxy_msg_id);
3269 3269 if (ic_reg_port) {
3270 3270 ic_ret = ic_tx_msg(ic_reg_port);
3271 3271 if (ic_ret == STMF_IC_MSG_SUCCESS) {
3272 3272 ilport->ilport_reg_msgid = stmf_proxy_msg_id++;
3273 3273 } else {
3274 3274 cmn_err(CE_WARN, "error on port registration "
3275 3275 "port - %s", ilport->ilport_kstat_tgt_name);
3276 3276 }
3277 3277 }
3278 3278 }
3279 3279 STMF_EVENT_ALLOC_HANDLE(ilport->ilport_event_hdl);
3280 3280 stmf_create_kstat_lport(ilport);
3281 3281 if (stmf_workers_state == STMF_WORKERS_DISABLED) {
3282 3282 stmf_workers_state = STMF_WORKERS_ENABLING;
3283 3283 start_workers = 1;
3284 3284 }
3285 3285 mutex_exit(&stmf_state.stmf_lock);
3286 3286
3287 3287 if (start_workers)
3288 3288 stmf_worker_init();
3289 3289
3290 3290 /* the default state of LPORT */
3291 3291
3292 3292 if (stmf_state.stmf_default_lport_state == STMF_STATE_OFFLINE) {
3293 3293 ilport->ilport_prev_state = STMF_STATE_OFFLINE;
3294 3294 } else {
3295 3295 ilport->ilport_prev_state = STMF_STATE_ONLINE;
3296 3296 if (stmf_state.stmf_service_running) {
3297 3297 ssci.st_rflags = 0;
3298 3298 ssci.st_additional_info = NULL;
3299 3299 (void) stmf_ctl(STMF_CMD_LPORT_ONLINE, lport, &ssci);
3300 3300 }
3301 3301 }
3302 3302
3303 3303 /* XXX: Generate event */
3304 3304 return (STMF_SUCCESS);
3305 3305 }
3306 3306
3307 3307 stmf_status_t
3308 3308 stmf_deregister_local_port(stmf_local_port_t *lport)
3309 3309 {
3310 3310 stmf_i_local_port_t *ilport;
3311 3311
3312 3312 mutex_enter(&stmf_state.stmf_lock);
3313 3313 if (stmf_state.stmf_inventory_locked) {
3314 3314 mutex_exit(&stmf_state.stmf_lock);
3315 3315 return (STMF_BUSY);
3316 3316 }
3317 3317
3318 3318 /* dequeue all object requests from active queue */
3319 3319 stmf_svc_kill_obj_requests(lport);
3320 3320
3321 3321 ilport = (stmf_i_local_port_t *)lport->lport_stmf_private;
3322 3322
3323 3323 /*
3324 3324 * deregister ports that are not standby (proxy)
3325 3325 */
3326 3326 if (stmf_state.stmf_alua_state == 1 &&
3327 3327 ilport->ilport_standby == 0 &&
3328 3328 ilport->ilport_alua == 1) {
3329 3329 stmf_ic_msg_t *ic_dereg_port;
3330 3330 stmf_ic_msg_status_t ic_ret;
3331 3331 ic_dereg_port = ic_dereg_port_msg_alloc(
3332 3332 lport->lport_id, 0, NULL, stmf_proxy_msg_id);
3333 3333 if (ic_dereg_port) {
3334 3334 ic_ret = ic_tx_msg(ic_dereg_port);
3335 3335 if (ic_ret == STMF_IC_MSG_SUCCESS) {
3336 3336 stmf_proxy_msg_id++;
3337 3337 }
3338 3338 }
3339 3339 }
3340 3340
3341 3341 if (ilport->ilport_nsessions == 0) {
3342 3342 if (ilport->ilport_next)
3343 3343 ilport->ilport_next->ilport_prev = ilport->ilport_prev;
3344 3344 if (ilport->ilport_prev)
3345 3345 ilport->ilport_prev->ilport_next = ilport->ilport_next;
3346 3346 else
3347 3347 stmf_state.stmf_ilportlist = ilport->ilport_next;
3348 3348 id_free(stmf_state.stmf_ilport_inst_space,
3349 3349 ilport->ilport_instance);
3350 3350 rw_destroy(&ilport->ilport_lock);
3351 3351 stmf_state.stmf_nlports--;
3352 3352 if (lport->lport_pp) {
3353 3353 ((stmf_i_port_provider_t *)
3354 3354 (lport->lport_pp->pp_stmf_private))->ipp_npps--;
3355 3355 }
3356 3356 ilport->ilport_tg = NULL;
3357 3357 STMF_EVENT_FREE_HANDLE(ilport->ilport_event_hdl);
3358 3358 } else {
3359 3359 mutex_exit(&stmf_state.stmf_lock);
3360 3360 return (STMF_BUSY);
3361 3361 }
3362 3362 if (ilport->ilport_kstat_info) {
3363 3363 kmem_free(ilport->ilport_kstat_info->ks_data,
3364 3364 ilport->ilport_kstat_info->ks_data_size);
3365 3365 kstat_delete(ilport->ilport_kstat_info);
3366 3366 }
3367 3367 if (ilport->ilport_kstat_io) {
3368 3368 kstat_delete(ilport->ilport_kstat_io);
3369 3369 mutex_destroy(&ilport->ilport_kstat_lock);
3370 3370 }
3371 3371 mutex_exit(&stmf_state.stmf_lock);
3372 3372 return (STMF_SUCCESS);
3373 3373 }
3374 3374
3375 3375 /*
3376 3376 * Rport id/instance mappings remain valid until STMF is unloaded
3377 3377 */
3378 3378 static int
3379 3379 stmf_irport_compare(const void *void_irport1, const void *void_irport2)
3380 3380 {
3381 3381 const stmf_i_remote_port_t *irport1 = void_irport1;
3382 3382 const stmf_i_remote_port_t *irport2 = void_irport2;
3383 3383 int result;
3384 3384
3385 3385 /* Sort by code set then ident */
3386 3386 if (irport1->irport_id->code_set <
3387 3387 irport2->irport_id->code_set) {
3388 3388 return (-1);
3389 3389 } else if (irport1->irport_id->code_set >
3390 3390 irport2->irport_id->code_set) {
3391 3391 return (1);
3392 3392 }
3393 3393
3394 3394 /* Next by ident length */
3395 3395 if (irport1->irport_id->ident_length <
3396 3396 irport2->irport_id->ident_length) {
3397 3397 return (-1);
3398 3398 } else if (irport1->irport_id->ident_length >
3399 3399 irport2->irport_id->ident_length) {
3400 3400 return (1);
3401 3401 }
3402 3402
3403 3403 /* Code set and ident length both match, now compare idents */
3404 3404 result = memcmp(irport1->irport_id->ident,
3405 3405 irport2->irport_id->ident,
3406 3406 irport1->irport_id->ident_length);
3407 3407
3408 3408 if (result < 0) {
3409 3409 return (-1);
3410 3410 } else if (result > 0) {
3411 3411 return (1);
3412 3412 }
3413 3413
3414 3414 return (0);
3415 3415 }
3416 3416
3417 3417 static stmf_i_remote_port_t *
3418 3418 stmf_irport_create(scsi_devid_desc_t *rport_devid)
3419 3419 {
3420 3420 int alloc_len;
3421 3421 stmf_i_remote_port_t *irport;
3422 3422
3423 3423 /*
3424 3424 * Lookup will bump the refcnt if there's an existing rport
3425 3425 * context for this identifier.
3426 3426 */
3427 3427 ASSERT(mutex_owned(&stmf_state.stmf_lock));
3428 3428
3429 3429 alloc_len = sizeof (*irport) + sizeof (scsi_devid_desc_t) +
3430 3430 rport_devid->ident_length - 1;
3431 3431 irport = kmem_zalloc(alloc_len, KM_NOSLEEP);
3432 3432 if (irport == NULL) {
3433 3433 return (NULL);
3434 3434 }
3435 3435
3436 3436 irport->irport_instance =
3437 3437 id_alloc_nosleep(stmf_state.stmf_irport_inst_space);
3438 3438 if (irport->irport_instance == -1) {
3439 3439 kmem_free(irport, alloc_len);
3440 3440 return (NULL);
3441 3441 }
3442 3442
3443 3443 irport->irport_id =
3444 3444 (struct scsi_devid_desc *)(irport + 1); /* Ptr. Arith. */
3445 3445 bcopy(rport_devid, irport->irport_id,
3446 3446 sizeof (scsi_devid_desc_t) + rport_devid->ident_length - 1);
3447 3447 irport->irport_refcnt = 1;
3448 3448 mutex_init(&irport->irport_mutex, NULL, MUTEX_DEFAULT, NULL);
3449 3449
3450 3450 return (irport);
3451 3451 }
3452 3452
3453 3453 static void
3454 3454 stmf_irport_destroy(stmf_i_remote_port_t *irport)
3455 3455 {
3456 3456 id_free(stmf_state.stmf_irport_inst_space, irport->irport_instance);
3457 3457 mutex_destroy(&irport->irport_mutex);
3458 3458 kmem_free(irport, sizeof (*irport) + sizeof (scsi_devid_desc_t) +
3459 3459 irport->irport_id->ident_length - 1);
3460 3460 }
3461 3461
3462 3462 static stmf_i_remote_port_t *
3463 3463 stmf_irport_register(scsi_devid_desc_t *rport_devid)
3464 3464 {
3465 3465 stmf_i_remote_port_t *irport;
3466 3466
3467 3467 mutex_enter(&stmf_state.stmf_lock);
3468 3468
3469 3469 /*
3470 3470 * Lookup will bump the refcnt if there's an existing rport
3471 3471 * context for this identifier.
3472 3472 */
3473 3473 if ((irport = stmf_irport_lookup_locked(rport_devid)) != NULL) {
3474 3474 mutex_exit(&stmf_state.stmf_lock);
3475 3475 return (irport);
3476 3476 }
3477 3477
3478 3478 irport = stmf_irport_create(rport_devid);
3479 3479 if (irport == NULL) {
3480 3480 mutex_exit(&stmf_state.stmf_lock);
3481 3481 return (NULL);
3482 3482 }
3483 3483
3484 3484 avl_add(&stmf_state.stmf_irportlist, irport);
3485 3485 mutex_exit(&stmf_state.stmf_lock);
3486 3486
3487 3487 return (irport);
3488 3488 }
3489 3489
3490 3490 static stmf_i_remote_port_t *
3491 3491 stmf_irport_lookup_locked(scsi_devid_desc_t *rport_devid)
3492 3492 {
3493 3493 stmf_i_remote_port_t *irport;
3494 3494 stmf_i_remote_port_t tmp_irport;
3495 3495
3496 3496 ASSERT(mutex_owned(&stmf_state.stmf_lock));
3497 3497 tmp_irport.irport_id = rport_devid;
3498 3498 irport = avl_find(&stmf_state.stmf_irportlist, &tmp_irport, NULL);
3499 3499 if (irport != NULL) {
3500 3500 mutex_enter(&irport->irport_mutex);
3501 3501 irport->irport_refcnt++;
3502 3502 mutex_exit(&irport->irport_mutex);
3503 3503 }
3504 3504
3505 3505 return (irport);
3506 3506 }
3507 3507
3508 3508 static void
3509 3509 stmf_irport_deregister(stmf_i_remote_port_t *irport)
3510 3510 {
3511 3511 /*
3512 3512 * If we were actually going to remove unreferenced remote ports
3513 3513 * we would want to acquire stmf_state.stmf_lock before getting
3514 3514 * the irport mutex.
3515 3515 *
3516 3516 * Instead we're just going to leave it there even if unreferenced.
3517 3517 */
3518 3518 mutex_enter(&irport->irport_mutex);
3519 3519 irport->irport_refcnt--;
3520 3520 mutex_exit(&irport->irport_mutex);
3521 3521 }
3522 3522
3523 3523 /*
3524 3524 * Port provider has to make sure that register/deregister session and
3525 3525 * port are serialized calls.
3526 3526 */
3527 3527 stmf_status_t
3528 3528 stmf_register_scsi_session(stmf_local_port_t *lport, stmf_scsi_session_t *ss)
3529 3529 {
3530 3530 stmf_i_scsi_session_t *iss;
3531 3531 stmf_i_local_port_t *ilport = (stmf_i_local_port_t *)
3532 3532 lport->lport_stmf_private;
3533 3533 uint8_t lun[8];
3534 3534
3535 3535 /*
3536 3536 * Port state has to be online to register a scsi session. It is
3537 3537 * possible that we started an offline operation and a new SCSI
3538 3538 * session started at the same time (in that case also we are going
3539 3539 * to fail the registeration). But any other state is simply
3540 3540 * a bad port provider implementation.
3541 3541 */
3542 3542 if (ilport->ilport_state != STMF_STATE_ONLINE) {
3543 3543 if (ilport->ilport_state != STMF_STATE_OFFLINING) {
3544 3544 stmf_trace(lport->lport_alias, "Port is trying to "
3545 3545 "register a session while the state is neither "
3546 3546 "online nor offlining");
3547 3547 }
3548 3548 return (STMF_FAILURE);
3549 3549 }
3550 3550 bzero(lun, 8);
3551 3551 iss = (stmf_i_scsi_session_t *)ss->ss_stmf_private;
3552 3552 if ((iss->iss_irport = stmf_irport_register(ss->ss_rport_id)) == NULL) {
3553 3553 stmf_trace(lport->lport_alias, "Could not register "
3554 3554 "remote port during session registration");
3555 3555 return (STMF_FAILURE);
3556 3556 }
3557 3557
3558 3558 iss->iss_flags |= ISS_BEING_CREATED;
3559 3559
3560 3560 if (ss->ss_rport == NULL) {
3561 3561 iss->iss_flags |= ISS_NULL_TPTID;
3562 3562 ss->ss_rport = stmf_scsilib_devid_to_remote_port(
3563 3563 ss->ss_rport_id);
3564 3564 if (ss->ss_rport == NULL) {
3565 3565 iss->iss_flags &= ~(ISS_NULL_TPTID | ISS_BEING_CREATED);
3566 3566 stmf_trace(lport->lport_alias, "Device id to "
3567 3567 "remote port conversion failed");
3568 3568 return (STMF_FAILURE);
3569 3569 }
3570 3570 } else {
3571 3571 if (!stmf_scsilib_tptid_validate(ss->ss_rport->rport_tptid,
3572 3572 ss->ss_rport->rport_tptid_sz, NULL)) {
3573 3573 iss->iss_flags &= ~ISS_BEING_CREATED;
3574 3574 stmf_trace(lport->lport_alias, "Remote port "
3575 3575 "transport id validation failed");
3576 3576 return (STMF_FAILURE);
3577 3577 }
3578 3578 }
3579 3579
3580 3580 /* sessions use the ilport_lock. No separate lock is required */
3581 3581 iss->iss_lockp = &ilport->ilport_lock;
3582 3582
3583 3583 if (iss->iss_sm != NULL)
3584 3584 cmn_err(CE_PANIC, "create lun map called with non NULL map");
3585 3585 iss->iss_sm = (stmf_lun_map_t *)kmem_zalloc(sizeof (stmf_lun_map_t),
3586 3586 KM_SLEEP);
3587 3587
|
↓ open down ↓ |
321 lines elided |
↑ open up ↑ |
3588 3588 mutex_enter(&stmf_state.stmf_lock);
3589 3589 rw_enter(&ilport->ilport_lock, RW_WRITER);
3590 3590 (void) stmf_session_create_lun_map(ilport, iss);
3591 3591 ilport->ilport_nsessions++;
3592 3592 iss->iss_next = ilport->ilport_ss_list;
3593 3593 ilport->ilport_ss_list = iss;
3594 3594 rw_exit(&ilport->ilport_lock);
3595 3595 mutex_exit(&stmf_state.stmf_lock);
3596 3596
3597 3597 iss->iss_creation_time = ddi_get_time();
3598 - ss->ss_session_id = atomic_add_64_nv(&stmf_session_counter, 1);
3598 + ss->ss_session_id = atomic_inc_64_nv(&stmf_session_counter);
3599 3599 iss->iss_flags &= ~ISS_BEING_CREATED;
3600 3600 /* XXX should we remove ISS_LUN_INVENTORY_CHANGED on new session? */
3601 3601 iss->iss_flags &= ~ISS_LUN_INVENTORY_CHANGED;
3602 3602 DTRACE_PROBE2(session__online, stmf_local_port_t *, lport,
3603 3603 stmf_scsi_session_t *, ss);
3604 3604 return (STMF_SUCCESS);
3605 3605 }
3606 3606
3607 3607 void
3608 3608 stmf_deregister_scsi_session(stmf_local_port_t *lport, stmf_scsi_session_t *ss)
3609 3609 {
3610 3610 stmf_i_local_port_t *ilport = (stmf_i_local_port_t *)
3611 3611 lport->lport_stmf_private;
3612 3612 stmf_i_scsi_session_t *iss, **ppss;
3613 3613 int found = 0;
3614 3614 stmf_ic_msg_t *ic_session_dereg;
3615 3615 stmf_status_t ic_ret = STMF_FAILURE;
3616 3616
3617 3617 DTRACE_PROBE2(session__offline, stmf_local_port_t *, lport,
3618 3618 stmf_scsi_session_t *, ss);
3619 3619
3620 3620 iss = (stmf_i_scsi_session_t *)ss->ss_stmf_private;
3621 3621 if (ss->ss_rport_alias) {
3622 3622 ss->ss_rport_alias = NULL;
3623 3623 }
3624 3624
3625 3625 try_dereg_ss_again:
3626 3626 mutex_enter(&stmf_state.stmf_lock);
3627 3627 atomic_and_32(&iss->iss_flags,
3628 3628 ~(ISS_LUN_INVENTORY_CHANGED | ISS_GOT_INITIAL_LUNS));
3629 3629 if (iss->iss_flags & ISS_EVENT_ACTIVE) {
3630 3630 mutex_exit(&stmf_state.stmf_lock);
3631 3631 delay(1);
3632 3632 goto try_dereg_ss_again;
3633 3633 }
3634 3634
3635 3635 /* dereg proxy session if not standby port */
3636 3636 if (stmf_state.stmf_alua_state == 1 &&
3637 3637 ilport->ilport_standby == 0 &&
3638 3638 ilport->ilport_alua == 1) {
3639 3639 ic_session_dereg = ic_session_dereg_msg_alloc(
3640 3640 ss, stmf_proxy_msg_id);
3641 3641 if (ic_session_dereg) {
3642 3642 ic_ret = ic_tx_msg(ic_session_dereg);
3643 3643 if (ic_ret == STMF_IC_MSG_SUCCESS) {
3644 3644 stmf_proxy_msg_id++;
3645 3645 }
3646 3646 }
3647 3647 }
3648 3648
3649 3649 rw_enter(&ilport->ilport_lock, RW_WRITER);
3650 3650 for (ppss = &ilport->ilport_ss_list; *ppss != NULL;
3651 3651 ppss = &((*ppss)->iss_next)) {
3652 3652 if (iss == (*ppss)) {
3653 3653 *ppss = (*ppss)->iss_next;
3654 3654 found = 1;
3655 3655 break;
3656 3656 }
3657 3657 }
3658 3658 if (!found) {
3659 3659 cmn_err(CE_PANIC, "Deregister session called for non existent"
3660 3660 " session");
3661 3661 }
3662 3662 ilport->ilport_nsessions--;
3663 3663
3664 3664 stmf_irport_deregister(iss->iss_irport);
3665 3665 (void) stmf_session_destroy_lun_map(ilport, iss);
3666 3666 rw_exit(&ilport->ilport_lock);
3667 3667 mutex_exit(&stmf_state.stmf_lock);
3668 3668
3669 3669 if (iss->iss_flags & ISS_NULL_TPTID) {
3670 3670 stmf_remote_port_free(ss->ss_rport);
3671 3671 }
3672 3672 }
3673 3673
3674 3674 stmf_i_scsi_session_t *
3675 3675 stmf_session_id_to_issptr(uint64_t session_id, int stay_locked)
3676 3676 {
3677 3677 stmf_i_local_port_t *ilport;
3678 3678 stmf_i_scsi_session_t *iss;
3679 3679
3680 3680 mutex_enter(&stmf_state.stmf_lock);
3681 3681 for (ilport = stmf_state.stmf_ilportlist; ilport != NULL;
3682 3682 ilport = ilport->ilport_next) {
3683 3683 rw_enter(&ilport->ilport_lock, RW_WRITER);
3684 3684 for (iss = ilport->ilport_ss_list; iss != NULL;
3685 3685 iss = iss->iss_next) {
3686 3686 if (iss->iss_ss->ss_session_id == session_id) {
3687 3687 if (!stay_locked)
3688 3688 rw_exit(&ilport->ilport_lock);
3689 3689 mutex_exit(&stmf_state.stmf_lock);
3690 3690 return (iss);
3691 3691 }
3692 3692 }
3693 3693 rw_exit(&ilport->ilport_lock);
3694 3694 }
3695 3695 mutex_exit(&stmf_state.stmf_lock);
3696 3696 return (NULL);
3697 3697 }
3698 3698
3699 3699 void
3700 3700 stmf_release_itl_handle(stmf_lu_t *lu, stmf_itl_data_t *itl)
3701 3701 {
3702 3702 stmf_itl_data_t **itlpp;
3703 3703 stmf_i_lu_t *ilu;
3704 3704
3705 3705 ASSERT(itl->itl_flags & STMF_ITL_BEING_TERMINATED);
3706 3706
3707 3707 ilu = (stmf_i_lu_t *)lu->lu_stmf_private;
3708 3708 mutex_enter(&ilu->ilu_task_lock);
3709 3709 for (itlpp = &ilu->ilu_itl_list; (*itlpp) != NULL;
3710 3710 itlpp = &(*itlpp)->itl_next) {
3711 3711 if ((*itlpp) == itl)
3712 3712 break;
3713 3713 }
3714 3714 ASSERT((*itlpp) != NULL);
3715 3715 *itlpp = itl->itl_next;
3716 3716 mutex_exit(&ilu->ilu_task_lock);
3717 3717 lu->lu_abort(lu, STMF_LU_ITL_HANDLE_REMOVED, itl->itl_handle,
3718 3718 (uint32_t)itl->itl_hdlrm_reason);
3719 3719
3720 3720 kmem_free(itl, sizeof (*itl));
3721 3721 }
3722 3722
3723 3723 stmf_status_t
3724 3724 stmf_register_itl_handle(stmf_lu_t *lu, uint8_t *lun,
3725 3725 stmf_scsi_session_t *ss, uint64_t session_id, void *itl_handle)
3726 3726 {
3727 3727 stmf_itl_data_t *itl;
3728 3728 stmf_i_scsi_session_t *iss;
3729 3729 stmf_lun_map_ent_t *lun_map_ent;
3730 3730 stmf_i_lu_t *ilu;
3731 3731 uint16_t n;
3732 3732
3733 3733 ilu = (stmf_i_lu_t *)lu->lu_stmf_private;
3734 3734 if (ss == NULL) {
3735 3735 iss = stmf_session_id_to_issptr(session_id, 1);
3736 3736 if (iss == NULL)
3737 3737 return (STMF_NOT_FOUND);
3738 3738 } else {
3739 3739 iss = (stmf_i_scsi_session_t *)ss->ss_stmf_private;
3740 3740 }
3741 3741
3742 3742 mutex_enter(&stmf_state.stmf_lock);
3743 3743 rw_enter(iss->iss_lockp, RW_WRITER);
3744 3744 n = ((uint16_t)lun[1] | (((uint16_t)(lun[0] & 0x3F)) << 8));
3745 3745 lun_map_ent = (stmf_lun_map_ent_t *)
3746 3746 stmf_get_ent_from_map(iss->iss_sm, n);
3747 3747 if ((lun_map_ent == NULL) || (lun_map_ent->ent_lu != lu)) {
3748 3748 rw_exit(iss->iss_lockp);
3749 3749 mutex_exit(&stmf_state.stmf_lock);
3750 3750 return (STMF_NOT_FOUND);
3751 3751 }
3752 3752 if (lun_map_ent->ent_itl_datap != NULL) {
3753 3753 rw_exit(iss->iss_lockp);
3754 3754 mutex_exit(&stmf_state.stmf_lock);
3755 3755 return (STMF_ALREADY);
3756 3756 }
3757 3757
3758 3758 itl = (stmf_itl_data_t *)kmem_zalloc(sizeof (*itl), KM_NOSLEEP);
3759 3759 if (itl == NULL) {
3760 3760 rw_exit(iss->iss_lockp);
3761 3761 mutex_exit(&stmf_state.stmf_lock);
3762 3762 return (STMF_ALLOC_FAILURE);
3763 3763 }
3764 3764
3765 3765 itl->itl_ilu = ilu;
3766 3766 itl->itl_session = iss;
3767 3767 itl->itl_counter = 1;
3768 3768 itl->itl_lun = n;
3769 3769 itl->itl_handle = itl_handle;
3770 3770
3771 3771 mutex_enter(&ilu->ilu_task_lock);
3772 3772 itl->itl_next = ilu->ilu_itl_list;
3773 3773 ilu->ilu_itl_list = itl;
3774 3774 mutex_exit(&ilu->ilu_task_lock);
3775 3775 lun_map_ent->ent_itl_datap = itl;
3776 3776 rw_exit(iss->iss_lockp);
3777 3777 mutex_exit(&stmf_state.stmf_lock);
3778 3778
3779 3779 return (STMF_SUCCESS);
3780 3780 }
3781 3781
3782 3782 void
3783 3783 stmf_do_itl_dereg(stmf_lu_t *lu, stmf_itl_data_t *itl, uint8_t hdlrm_reason)
3784 3784 {
3785 3785 uint8_t old, new;
3786 3786
|
↓ open down ↓ |
178 lines elided |
↑ open up ↑ |
3787 3787 do {
3788 3788 old = new = itl->itl_flags;
3789 3789 if (old & STMF_ITL_BEING_TERMINATED)
3790 3790 return;
3791 3791 new |= STMF_ITL_BEING_TERMINATED;
3792 3792 } while (atomic_cas_8(&itl->itl_flags, old, new) != old);
3793 3793 itl->itl_hdlrm_reason = hdlrm_reason;
3794 3794
3795 3795 ASSERT(itl->itl_counter);
3796 3796
3797 - if (atomic_add_32_nv(&itl->itl_counter, -1))
3797 + if (atomic_dec_32_nv(&itl->itl_counter))
3798 3798 return;
3799 3799
3800 3800 stmf_release_itl_handle(lu, itl);
3801 3801 }
3802 3802
3803 3803 stmf_status_t
3804 3804 stmf_deregister_all_lu_itl_handles(stmf_lu_t *lu)
3805 3805 {
3806 3806 stmf_i_lu_t *ilu;
3807 3807 stmf_i_local_port_t *ilport;
3808 3808 stmf_i_scsi_session_t *iss;
3809 3809 stmf_lun_map_t *lm;
3810 3810 stmf_lun_map_ent_t *ent;
3811 3811 uint32_t nmaps, nu;
3812 3812 stmf_itl_data_t **itl_list;
3813 3813 int i;
3814 3814
3815 3815 ilu = (stmf_i_lu_t *)lu->lu_stmf_private;
3816 3816
3817 3817 dereg_itl_start:;
3818 3818 nmaps = ilu->ilu_ref_cnt;
3819 3819 if (nmaps == 0)
3820 3820 return (STMF_NOT_FOUND);
3821 3821 itl_list = (stmf_itl_data_t **)kmem_zalloc(
3822 3822 nmaps * sizeof (stmf_itl_data_t *), KM_SLEEP);
3823 3823 mutex_enter(&stmf_state.stmf_lock);
3824 3824 if (nmaps != ilu->ilu_ref_cnt) {
3825 3825 /* Something changed, start all over */
3826 3826 mutex_exit(&stmf_state.stmf_lock);
3827 3827 kmem_free(itl_list, nmaps * sizeof (stmf_itl_data_t *));
3828 3828 goto dereg_itl_start;
3829 3829 }
3830 3830 nu = 0;
3831 3831 for (ilport = stmf_state.stmf_ilportlist; ilport != NULL;
3832 3832 ilport = ilport->ilport_next) {
3833 3833 rw_enter(&ilport->ilport_lock, RW_WRITER);
3834 3834 for (iss = ilport->ilport_ss_list; iss != NULL;
3835 3835 iss = iss->iss_next) {
3836 3836 lm = iss->iss_sm;
3837 3837 if (!lm)
3838 3838 continue;
3839 3839 for (i = 0; i < lm->lm_nentries; i++) {
3840 3840 if (lm->lm_plus[i] == NULL)
3841 3841 continue;
3842 3842 ent = (stmf_lun_map_ent_t *)lm->lm_plus[i];
3843 3843 if ((ent->ent_lu == lu) &&
3844 3844 (ent->ent_itl_datap)) {
3845 3845 itl_list[nu++] = ent->ent_itl_datap;
3846 3846 ent->ent_itl_datap = NULL;
3847 3847 if (nu == nmaps) {
3848 3848 rw_exit(&ilport->ilport_lock);
3849 3849 goto dai_scan_done;
3850 3850 }
3851 3851 }
3852 3852 } /* lun table for a session */
3853 3853 } /* sessions */
3854 3854 rw_exit(&ilport->ilport_lock);
3855 3855 } /* ports */
3856 3856
3857 3857 dai_scan_done:
3858 3858 mutex_exit(&stmf_state.stmf_lock);
3859 3859
3860 3860 for (i = 0; i < nu; i++) {
3861 3861 stmf_do_itl_dereg(lu, itl_list[i],
3862 3862 STMF_ITL_REASON_DEREG_REQUEST);
3863 3863 }
3864 3864 kmem_free(itl_list, nmaps * sizeof (stmf_itl_data_t *));
3865 3865
3866 3866 return (STMF_SUCCESS);
3867 3867 }
3868 3868
3869 3869 stmf_status_t
3870 3870 stmf_get_itl_handle(stmf_lu_t *lu, uint8_t *lun, stmf_scsi_session_t *ss,
3871 3871 uint64_t session_id, void **itl_handle_retp)
3872 3872 {
3873 3873 stmf_i_scsi_session_t *iss;
3874 3874 stmf_lun_map_ent_t *ent;
3875 3875 stmf_lun_map_t *lm;
3876 3876 stmf_status_t ret;
3877 3877 int i;
3878 3878 uint16_t n;
3879 3879
3880 3880 if (ss == NULL) {
3881 3881 iss = stmf_session_id_to_issptr(session_id, 1);
3882 3882 if (iss == NULL)
3883 3883 return (STMF_NOT_FOUND);
3884 3884 } else {
3885 3885 iss = (stmf_i_scsi_session_t *)ss->ss_stmf_private;
3886 3886 rw_enter(iss->iss_lockp, RW_WRITER);
3887 3887 }
3888 3888
3889 3889 ent = NULL;
3890 3890 if (lun == NULL) {
3891 3891 lm = iss->iss_sm;
3892 3892 for (i = 0; i < lm->lm_nentries; i++) {
3893 3893 if (lm->lm_plus[i] == NULL)
3894 3894 continue;
3895 3895 ent = (stmf_lun_map_ent_t *)lm->lm_plus[i];
3896 3896 if (ent->ent_lu == lu)
3897 3897 break;
3898 3898 }
3899 3899 } else {
3900 3900 n = ((uint16_t)lun[1] | (((uint16_t)(lun[0] & 0x3F)) << 8));
3901 3901 ent = (stmf_lun_map_ent_t *)
3902 3902 stmf_get_ent_from_map(iss->iss_sm, n);
3903 3903 if (lu && (ent->ent_lu != lu))
3904 3904 ent = NULL;
3905 3905 }
3906 3906 if (ent && ent->ent_itl_datap) {
3907 3907 *itl_handle_retp = ent->ent_itl_datap->itl_handle;
3908 3908 ret = STMF_SUCCESS;
3909 3909 } else {
3910 3910 ret = STMF_NOT_FOUND;
3911 3911 }
3912 3912
3913 3913 rw_exit(iss->iss_lockp);
3914 3914 return (ret);
3915 3915 }
3916 3916
3917 3917 stmf_data_buf_t *
3918 3918 stmf_alloc_dbuf(scsi_task_t *task, uint32_t size, uint32_t *pminsize,
3919 3919 uint32_t flags)
3920 3920 {
3921 3921 stmf_i_scsi_task_t *itask =
3922 3922 (stmf_i_scsi_task_t *)task->task_stmf_private;
3923 3923 stmf_local_port_t *lport = task->task_lport;
3924 3924 stmf_data_buf_t *dbuf;
3925 3925 uint8_t ndx;
3926 3926
3927 3927 ndx = stmf_first_zero[itask->itask_allocated_buf_map];
3928 3928 if (ndx == 0xff)
3929 3929 return (NULL);
3930 3930 dbuf = itask->itask_dbufs[ndx] = lport->lport_ds->ds_alloc_data_buf(
3931 3931 task, size, pminsize, flags);
3932 3932 if (dbuf) {
3933 3933 task->task_cur_nbufs++;
3934 3934 itask->itask_allocated_buf_map |= (1 << ndx);
3935 3935 dbuf->db_flags &= ~DB_LPORT_XFER_ACTIVE;
3936 3936 dbuf->db_handle = ndx;
3937 3937 return (dbuf);
3938 3938 }
3939 3939
3940 3940 return (NULL);
3941 3941 }
3942 3942
3943 3943 stmf_status_t
3944 3944 stmf_setup_dbuf(scsi_task_t *task, stmf_data_buf_t *dbuf, uint32_t flags)
3945 3945 {
3946 3946 stmf_i_scsi_task_t *itask =
3947 3947 (stmf_i_scsi_task_t *)task->task_stmf_private;
3948 3948 stmf_local_port_t *lport = task->task_lport;
3949 3949 uint8_t ndx;
3950 3950 stmf_status_t ret;
3951 3951
3952 3952 ASSERT(task->task_additional_flags & TASK_AF_ACCEPT_LU_DBUF);
3953 3953 ASSERT(lport->lport_ds->ds_setup_dbuf != NULL);
3954 3954 ASSERT(dbuf->db_flags & DB_LU_DATA_BUF);
3955 3955
3956 3956 if ((task->task_additional_flags & TASK_AF_ACCEPT_LU_DBUF) == 0)
3957 3957 return (STMF_FAILURE);
3958 3958 if (lport->lport_ds->ds_setup_dbuf == NULL)
3959 3959 return (STMF_FAILURE);
3960 3960
3961 3961 ndx = stmf_first_zero[itask->itask_allocated_buf_map];
3962 3962 if (ndx == 0xff)
3963 3963 return (STMF_FAILURE);
3964 3964 ret = lport->lport_ds->ds_setup_dbuf(task, dbuf, flags);
3965 3965 if (ret == STMF_FAILURE)
3966 3966 return (STMF_FAILURE);
3967 3967 itask->itask_dbufs[ndx] = dbuf;
3968 3968 task->task_cur_nbufs++;
3969 3969 itask->itask_allocated_buf_map |= (1 << ndx);
3970 3970 dbuf->db_handle = ndx;
3971 3971
3972 3972 return (STMF_SUCCESS);
3973 3973 }
3974 3974
3975 3975 void
3976 3976 stmf_teardown_dbuf(scsi_task_t *task, stmf_data_buf_t *dbuf)
3977 3977 {
3978 3978 stmf_i_scsi_task_t *itask =
3979 3979 (stmf_i_scsi_task_t *)task->task_stmf_private;
3980 3980 stmf_local_port_t *lport = task->task_lport;
3981 3981
3982 3982 ASSERT(task->task_additional_flags & TASK_AF_ACCEPT_LU_DBUF);
3983 3983 ASSERT(lport->lport_ds->ds_teardown_dbuf != NULL);
3984 3984 ASSERT(dbuf->db_flags & DB_LU_DATA_BUF);
3985 3985
3986 3986 itask->itask_allocated_buf_map &= ~(1 << dbuf->db_handle);
3987 3987 task->task_cur_nbufs--;
3988 3988 lport->lport_ds->ds_teardown_dbuf(lport->lport_ds, dbuf);
3989 3989 }
3990 3990
3991 3991 void
3992 3992 stmf_free_dbuf(scsi_task_t *task, stmf_data_buf_t *dbuf)
3993 3993 {
3994 3994 stmf_i_scsi_task_t *itask =
3995 3995 (stmf_i_scsi_task_t *)task->task_stmf_private;
3996 3996 stmf_local_port_t *lport = task->task_lport;
3997 3997
3998 3998 itask->itask_allocated_buf_map &= ~(1 << dbuf->db_handle);
3999 3999 task->task_cur_nbufs--;
4000 4000 lport->lport_ds->ds_free_data_buf(lport->lport_ds, dbuf);
4001 4001 }
4002 4002
4003 4003 stmf_data_buf_t *
4004 4004 stmf_handle_to_buf(scsi_task_t *task, uint8_t h)
4005 4005 {
4006 4006 stmf_i_scsi_task_t *itask;
4007 4007
4008 4008 itask = (stmf_i_scsi_task_t *)task->task_stmf_private;
4009 4009 if (h > 3)
4010 4010 return (NULL);
4011 4011 return (itask->itask_dbufs[h]);
4012 4012 }
4013 4013
4014 4014 /* ARGSUSED */
4015 4015 struct scsi_task *
4016 4016 stmf_task_alloc(struct stmf_local_port *lport, stmf_scsi_session_t *ss,
4017 4017 uint8_t *lun, uint16_t cdb_length_in, uint16_t ext_id)
4018 4018 {
4019 4019 stmf_lu_t *lu;
4020 4020 stmf_i_scsi_session_t *iss;
4021 4021 stmf_i_lu_t *ilu;
4022 4022 stmf_i_scsi_task_t *itask;
4023 4023 stmf_i_scsi_task_t **ppitask;
4024 4024 scsi_task_t *task;
4025 4025 uint8_t *l;
4026 4026 stmf_lun_map_ent_t *lun_map_ent;
4027 4027 uint16_t cdb_length;
4028 4028 uint16_t luNbr;
4029 4029 uint8_t new_task = 0;
4030 4030
4031 4031 /*
4032 4032 * We allocate 7 extra bytes for CDB to provide a cdb pointer which
4033 4033 * is guaranteed to be 8 byte aligned. Some LU providers like OSD
4034 4034 * depend upon this alignment.
4035 4035 */
4036 4036 if (cdb_length_in >= 16)
4037 4037 cdb_length = cdb_length_in + 7;
4038 4038 else
4039 4039 cdb_length = 16 + 7;
4040 4040 iss = (stmf_i_scsi_session_t *)ss->ss_stmf_private;
4041 4041 luNbr = ((uint16_t)lun[1] | (((uint16_t)(lun[0] & 0x3F)) << 8));
4042 4042 rw_enter(iss->iss_lockp, RW_READER);
4043 4043 lun_map_ent =
4044 4044 (stmf_lun_map_ent_t *)stmf_get_ent_from_map(iss->iss_sm, luNbr);
4045 4045 if (!lun_map_ent) {
4046 4046 lu = dlun0;
4047 4047 } else {
4048 4048 lu = lun_map_ent->ent_lu;
4049 4049 }
4050 4050 ilu = lu->lu_stmf_private;
4051 4051 if (ilu->ilu_flags & ILU_RESET_ACTIVE) {
4052 4052 rw_exit(iss->iss_lockp);
4053 4053 return (NULL);
4054 4054 }
4055 4055 ASSERT(lu == dlun0 || (ilu->ilu_state != STMF_STATE_OFFLINING &&
4056 4056 ilu->ilu_state != STMF_STATE_OFFLINE));
4057 4057 do {
4058 4058 if (ilu->ilu_free_tasks == NULL) {
4059 4059 new_task = 1;
4060 4060 break;
4061 4061 }
4062 4062 mutex_enter(&ilu->ilu_task_lock);
4063 4063 for (ppitask = &ilu->ilu_free_tasks; (*ppitask != NULL) &&
4064 4064 ((*ppitask)->itask_cdb_buf_size < cdb_length);
4065 4065 ppitask = &((*ppitask)->itask_lu_free_next))
4066 4066 ;
4067 4067 if (*ppitask) {
4068 4068 itask = *ppitask;
4069 4069 *ppitask = (*ppitask)->itask_lu_free_next;
4070 4070 ilu->ilu_ntasks_free--;
4071 4071 if (ilu->ilu_ntasks_free < ilu->ilu_ntasks_min_free)
4072 4072 ilu->ilu_ntasks_min_free = ilu->ilu_ntasks_free;
4073 4073 } else {
4074 4074 new_task = 1;
4075 4075 }
4076 4076 mutex_exit(&ilu->ilu_task_lock);
4077 4077 /* CONSTCOND */
4078 4078 } while (0);
4079 4079
4080 4080 if (!new_task) {
4081 4081 /*
4082 4082 * Save the task_cdb pointer and zero per cmd fields.
4083 4083 * We know the task_cdb_length is large enough by task
4084 4084 * selection process above.
4085 4085 */
4086 4086 uint8_t *save_cdb;
4087 4087 uintptr_t t_start, t_end;
4088 4088
4089 4089 task = itask->itask_task;
4090 4090 save_cdb = task->task_cdb; /* save */
4091 4091 t_start = (uintptr_t)&task->task_flags;
4092 4092 t_end = (uintptr_t)&task->task_extended_cmd;
4093 4093 bzero((void *)t_start, (size_t)(t_end - t_start));
4094 4094 task->task_cdb = save_cdb; /* restore */
4095 4095 itask->itask_ncmds = 0;
4096 4096 } else {
4097 4097 task = (scsi_task_t *)stmf_alloc(STMF_STRUCT_SCSI_TASK,
4098 4098 cdb_length, AF_FORCE_NOSLEEP);
4099 4099 if (task == NULL) {
4100 4100 rw_exit(iss->iss_lockp);
4101 4101 return (NULL);
4102 4102 }
4103 4103 task->task_lu = lu;
4104 4104 l = task->task_lun_no;
4105 4105 l[0] = lun[0];
4106 4106 l[1] = lun[1];
4107 4107 l[2] = lun[2];
4108 4108 l[3] = lun[3];
4109 4109 l[4] = lun[4];
4110 4110 l[5] = lun[5];
4111 4111 l[6] = lun[6];
4112 4112 l[7] = lun[7];
4113 4113 task->task_cdb = (uint8_t *)task->task_port_private;
4114 4114 if ((ulong_t)(task->task_cdb) & 7ul) {
4115 4115 task->task_cdb = (uint8_t *)(((ulong_t)
4116 4116 (task->task_cdb) + 7ul) & ~(7ul));
4117 4117 }
4118 4118 itask = (stmf_i_scsi_task_t *)task->task_stmf_private;
4119 4119 itask->itask_cdb_buf_size = cdb_length;
4120 4120 mutex_init(&itask->itask_audit_mutex, NULL, MUTEX_DRIVER, NULL);
4121 4121 }
4122 4122 task->task_session = ss;
4123 4123 task->task_lport = lport;
4124 4124 task->task_cdb_length = cdb_length_in;
4125 4125 itask->itask_flags = ITASK_IN_TRANSITION;
4126 4126 itask->itask_waitq_time = 0;
4127 4127 itask->itask_lu_read_time = itask->itask_lu_write_time = 0;
4128 4128 itask->itask_lport_read_time = itask->itask_lport_write_time = 0;
4129 4129 itask->itask_read_xfer = itask->itask_write_xfer = 0;
4130 4130 itask->itask_audit_index = 0;
4131 4131
4132 4132 if (new_task) {
4133 4133 if (lu->lu_task_alloc(task) != STMF_SUCCESS) {
4134 4134 rw_exit(iss->iss_lockp);
4135 4135 stmf_free(task);
4136 4136 return (NULL);
4137 4137 }
4138 4138 mutex_enter(&ilu->ilu_task_lock);
4139 4139 if (ilu->ilu_flags & ILU_RESET_ACTIVE) {
4140 4140 mutex_exit(&ilu->ilu_task_lock);
4141 4141 rw_exit(iss->iss_lockp);
4142 4142 stmf_free(task);
4143 4143 return (NULL);
4144 4144 }
|
↓ open down ↓ |
337 lines elided |
↑ open up ↑ |
4145 4145 itask->itask_lu_next = ilu->ilu_tasks;
4146 4146 if (ilu->ilu_tasks)
4147 4147 ilu->ilu_tasks->itask_lu_prev = itask;
4148 4148 ilu->ilu_tasks = itask;
4149 4149 /* kmem_zalloc automatically makes itask->itask_lu_prev NULL */
4150 4150 ilu->ilu_ntasks++;
4151 4151 mutex_exit(&ilu->ilu_task_lock);
4152 4152 }
4153 4153
4154 4154 itask->itask_ilu_task_cntr = ilu->ilu_cur_task_cntr;
4155 - atomic_add_32(itask->itask_ilu_task_cntr, 1);
4155 + atomic_inc_32(itask->itask_ilu_task_cntr);
4156 4156 itask->itask_start_time = ddi_get_lbolt();
4157 4157
4158 4158 if ((lun_map_ent != NULL) && ((itask->itask_itl_datap =
4159 4159 lun_map_ent->ent_itl_datap) != NULL)) {
4160 - atomic_add_32(&itask->itask_itl_datap->itl_counter, 1);
4160 + atomic_inc_32(&itask->itask_itl_datap->itl_counter);
4161 4161 task->task_lu_itl_handle = itask->itask_itl_datap->itl_handle;
4162 4162 } else {
4163 4163 itask->itask_itl_datap = NULL;
4164 4164 task->task_lu_itl_handle = NULL;
4165 4165 }
4166 4166
4167 4167 rw_exit(iss->iss_lockp);
4168 4168 return (task);
4169 4169 }
4170 4170
4171 4171 static void
4172 4172 stmf_task_lu_free(scsi_task_t *task, stmf_i_scsi_session_t *iss)
4173 4173 {
4174 4174 stmf_i_scsi_task_t *itask =
4175 4175 (stmf_i_scsi_task_t *)task->task_stmf_private;
4176 4176 stmf_i_lu_t *ilu = (stmf_i_lu_t *)task->task_lu->lu_stmf_private;
4177 4177
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
4178 4178 ASSERT(rw_lock_held(iss->iss_lockp));
4179 4179 itask->itask_flags = ITASK_IN_FREE_LIST;
4180 4180 itask->itask_proxy_msg_id = 0;
4181 4181 mutex_enter(&ilu->ilu_task_lock);
4182 4182 itask->itask_lu_free_next = ilu->ilu_free_tasks;
4183 4183 ilu->ilu_free_tasks = itask;
4184 4184 ilu->ilu_ntasks_free++;
4185 4185 if (ilu->ilu_ntasks == ilu->ilu_ntasks_free)
4186 4186 cv_signal(&ilu->ilu_offline_pending_cv);
4187 4187 mutex_exit(&ilu->ilu_task_lock);
4188 - atomic_add_32(itask->itask_ilu_task_cntr, -1);
4188 + atomic_dec_32(itask->itask_ilu_task_cntr);
4189 4189 }
4190 4190
4191 4191 void
4192 4192 stmf_task_lu_check_freelist(stmf_i_lu_t *ilu)
4193 4193 {
4194 4194 uint32_t num_to_release, ndx;
4195 4195 stmf_i_scsi_task_t *itask;
4196 4196 stmf_lu_t *lu = ilu->ilu_lu;
4197 4197
4198 4198 ASSERT(ilu->ilu_ntasks_min_free <= ilu->ilu_ntasks_free);
4199 4199
4200 4200 /* free half of the minimal free of the free tasks */
4201 4201 num_to_release = (ilu->ilu_ntasks_min_free + 1) / 2;
4202 4202 if (!num_to_release) {
4203 4203 return;
4204 4204 }
4205 4205 for (ndx = 0; ndx < num_to_release; ndx++) {
4206 4206 mutex_enter(&ilu->ilu_task_lock);
4207 4207 itask = ilu->ilu_free_tasks;
4208 4208 if (itask == NULL) {
4209 4209 mutex_exit(&ilu->ilu_task_lock);
4210 4210 break;
4211 4211 }
4212 4212 ilu->ilu_free_tasks = itask->itask_lu_free_next;
4213 4213 ilu->ilu_ntasks_free--;
4214 4214 mutex_exit(&ilu->ilu_task_lock);
4215 4215
4216 4216 lu->lu_task_free(itask->itask_task);
4217 4217 mutex_enter(&ilu->ilu_task_lock);
4218 4218 if (itask->itask_lu_next)
4219 4219 itask->itask_lu_next->itask_lu_prev =
4220 4220 itask->itask_lu_prev;
4221 4221 if (itask->itask_lu_prev)
4222 4222 itask->itask_lu_prev->itask_lu_next =
4223 4223 itask->itask_lu_next;
4224 4224 else
4225 4225 ilu->ilu_tasks = itask->itask_lu_next;
4226 4226
4227 4227 ilu->ilu_ntasks--;
4228 4228 mutex_exit(&ilu->ilu_task_lock);
4229 4229 stmf_free(itask->itask_task);
4230 4230 }
4231 4231 }
4232 4232
4233 4233 /*
4234 4234 * Called with stmf_lock held
4235 4235 */
4236 4236 void
4237 4237 stmf_check_freetask()
4238 4238 {
4239 4239 stmf_i_lu_t *ilu;
4240 4240 clock_t endtime = ddi_get_lbolt() + drv_usectohz(10000);
4241 4241
4242 4242 /* stmf_svc_ilu_draining may get changed after stmf_lock is released */
4243 4243 while ((ilu = stmf_state.stmf_svc_ilu_draining) != NULL) {
4244 4244 stmf_state.stmf_svc_ilu_draining = ilu->ilu_next;
4245 4245 if (!ilu->ilu_ntasks_min_free) {
4246 4246 ilu->ilu_ntasks_min_free = ilu->ilu_ntasks_free;
4247 4247 continue;
4248 4248 }
4249 4249 ilu->ilu_flags |= ILU_STALL_DEREGISTER;
4250 4250 mutex_exit(&stmf_state.stmf_lock);
4251 4251 stmf_task_lu_check_freelist(ilu);
4252 4252 /*
4253 4253 * we do not care about the accuracy of
4254 4254 * ilu_ntasks_min_free, so we don't lock here
4255 4255 */
4256 4256 ilu->ilu_ntasks_min_free = ilu->ilu_ntasks_free;
4257 4257 mutex_enter(&stmf_state.stmf_lock);
4258 4258 ilu->ilu_flags &= ~ILU_STALL_DEREGISTER;
4259 4259 cv_broadcast(&stmf_state.stmf_cv);
4260 4260 if (ddi_get_lbolt() >= endtime)
4261 4261 break;
4262 4262 }
4263 4263 }
4264 4264
4265 4265 void
4266 4266 stmf_do_ilu_timeouts(stmf_i_lu_t *ilu)
4267 4267 {
4268 4268 clock_t l = ddi_get_lbolt();
4269 4269 clock_t ps = drv_usectohz(1000000);
4270 4270 stmf_i_scsi_task_t *itask;
4271 4271 scsi_task_t *task;
4272 4272 uint32_t to;
4273 4273
4274 4274 mutex_enter(&ilu->ilu_task_lock);
4275 4275 for (itask = ilu->ilu_tasks; itask != NULL;
4276 4276 itask = itask->itask_lu_next) {
4277 4277 if (itask->itask_flags & (ITASK_IN_FREE_LIST |
4278 4278 ITASK_BEING_ABORTED)) {
4279 4279 continue;
4280 4280 }
4281 4281 task = itask->itask_task;
4282 4282 if (task->task_timeout == 0)
4283 4283 to = stmf_default_task_timeout;
4284 4284 else
4285 4285 to = task->task_timeout;
4286 4286 if ((itask->itask_start_time + (to * ps)) > l)
4287 4287 continue;
4288 4288 stmf_abort(STMF_QUEUE_TASK_ABORT, task,
4289 4289 STMF_TIMEOUT, NULL);
4290 4290 }
4291 4291 mutex_exit(&ilu->ilu_task_lock);
4292 4292 }
4293 4293
4294 4294 /*
4295 4295 * Called with stmf_lock held
4296 4296 */
4297 4297 void
4298 4298 stmf_check_ilu_timing()
4299 4299 {
4300 4300 stmf_i_lu_t *ilu;
4301 4301 clock_t endtime = ddi_get_lbolt() + drv_usectohz(10000);
4302 4302
4303 4303 /* stmf_svc_ilu_timing may get changed after stmf_lock is released */
4304 4304 while ((ilu = stmf_state.stmf_svc_ilu_timing) != NULL) {
4305 4305 stmf_state.stmf_svc_ilu_timing = ilu->ilu_next;
4306 4306 if (ilu->ilu_cur_task_cntr == (&ilu->ilu_task_cntr1)) {
4307 4307 if (ilu->ilu_task_cntr2 == 0) {
4308 4308 ilu->ilu_cur_task_cntr = &ilu->ilu_task_cntr2;
4309 4309 continue;
4310 4310 }
4311 4311 } else {
4312 4312 if (ilu->ilu_task_cntr1 == 0) {
4313 4313 ilu->ilu_cur_task_cntr = &ilu->ilu_task_cntr1;
4314 4314 continue;
4315 4315 }
4316 4316 }
4317 4317 /*
4318 4318 * If we are here then it means that there is some slowdown
4319 4319 * in tasks on this lu. We need to check.
4320 4320 */
4321 4321 ilu->ilu_flags |= ILU_STALL_DEREGISTER;
4322 4322 mutex_exit(&stmf_state.stmf_lock);
4323 4323 stmf_do_ilu_timeouts(ilu);
4324 4324 mutex_enter(&stmf_state.stmf_lock);
4325 4325 ilu->ilu_flags &= ~ILU_STALL_DEREGISTER;
4326 4326 cv_broadcast(&stmf_state.stmf_cv);
4327 4327 if (ddi_get_lbolt() >= endtime)
4328 4328 break;
4329 4329 }
4330 4330 }
4331 4331
4332 4332 /*
4333 4333 * Kills all tasks on a lu except tm_task
4334 4334 */
4335 4335 void
4336 4336 stmf_task_lu_killall(stmf_lu_t *lu, scsi_task_t *tm_task, stmf_status_t s)
4337 4337 {
4338 4338 stmf_i_lu_t *ilu = (stmf_i_lu_t *)lu->lu_stmf_private;
4339 4339 stmf_i_scsi_task_t *itask;
4340 4340
4341 4341 mutex_enter(&ilu->ilu_task_lock);
4342 4342
4343 4343 for (itask = ilu->ilu_tasks; itask != NULL;
4344 4344 itask = itask->itask_lu_next) {
4345 4345 if (itask->itask_flags & ITASK_IN_FREE_LIST)
4346 4346 continue;
4347 4347 if (itask->itask_task == tm_task)
4348 4348 continue;
4349 4349 stmf_abort(STMF_QUEUE_TASK_ABORT, itask->itask_task, s, NULL);
4350 4350 }
4351 4351 mutex_exit(&ilu->ilu_task_lock);
4352 4352 }
4353 4353
4354 4354 void
4355 4355 stmf_free_task_bufs(stmf_i_scsi_task_t *itask, stmf_local_port_t *lport)
4356 4356 {
4357 4357 int i;
4358 4358 uint8_t map;
4359 4359
4360 4360 if ((map = itask->itask_allocated_buf_map) == 0)
4361 4361 return;
4362 4362 for (i = 0; i < 4; i++) {
4363 4363 if (map & 1) {
4364 4364 stmf_data_buf_t *dbuf;
4365 4365
4366 4366 dbuf = itask->itask_dbufs[i];
4367 4367 if (dbuf->db_xfer_start_timestamp) {
4368 4368 stmf_lport_xfer_done(itask, dbuf);
4369 4369 }
4370 4370 if (dbuf->db_flags & DB_LU_DATA_BUF) {
4371 4371 /*
4372 4372 * LU needs to clean up buffer.
4373 4373 * LU is required to free the buffer
4374 4374 * in the xfer_done handler.
4375 4375 */
4376 4376 scsi_task_t *task = itask->itask_task;
4377 4377 stmf_lu_t *lu = task->task_lu;
4378 4378
4379 4379 lu->lu_dbuf_free(task, dbuf);
4380 4380 ASSERT(((itask->itask_allocated_buf_map>>i)
4381 4381 & 1) == 0); /* must be gone */
4382 4382 } else {
4383 4383 ASSERT(dbuf->db_lu_private == NULL);
4384 4384 dbuf->db_lu_private = NULL;
4385 4385 lport->lport_ds->ds_free_data_buf(
4386 4386 lport->lport_ds, dbuf);
4387 4387 }
4388 4388 }
4389 4389 map >>= 1;
4390 4390 }
4391 4391 itask->itask_allocated_buf_map = 0;
4392 4392 }
4393 4393
4394 4394 void
4395 4395 stmf_task_free(scsi_task_t *task)
4396 4396 {
4397 4397 stmf_local_port_t *lport = task->task_lport;
4398 4398 stmf_i_scsi_task_t *itask = (stmf_i_scsi_task_t *)
4399 4399 task->task_stmf_private;
4400 4400 stmf_i_scsi_session_t *iss = (stmf_i_scsi_session_t *)
|
↓ open down ↓ |
202 lines elided |
↑ open up ↑ |
4401 4401 task->task_session->ss_stmf_private;
4402 4402
4403 4403 stmf_task_audit(itask, TE_TASK_FREE, CMD_OR_IOF_NA, NULL);
4404 4404
4405 4405 stmf_free_task_bufs(itask, lport);
4406 4406 stmf_itl_task_done(itask);
4407 4407 DTRACE_PROBE2(stmf__task__end, scsi_task_t *, task,
4408 4408 hrtime_t,
4409 4409 itask->itask_done_timestamp - itask->itask_start_timestamp);
4410 4410 if (itask->itask_itl_datap) {
4411 - if (atomic_add_32_nv(&itask->itask_itl_datap->itl_counter,
4412 - -1) == 0) {
4411 + if (atomic_dec_32_nv(&itask->itask_itl_datap->itl_counter) ==
4412 + 0) {
4413 4413 stmf_release_itl_handle(task->task_lu,
4414 4414 itask->itask_itl_datap);
4415 4415 }
4416 4416 }
4417 4417
4418 4418 rw_enter(iss->iss_lockp, RW_READER);
4419 4419 lport->lport_task_free(task);
4420 4420 if (itask->itask_worker) {
4421 - atomic_add_32(&stmf_cur_ntasks, -1);
4422 - atomic_add_32(&itask->itask_worker->worker_ref_count, -1);
4421 + atomic_dec_32(&stmf_cur_ntasks);
4422 + atomic_dec_32(&itask->itask_worker->worker_ref_count);
4423 4423 }
4424 4424 /*
4425 4425 * After calling stmf_task_lu_free, the task pointer can no longer
4426 4426 * be trusted.
4427 4427 */
4428 4428 stmf_task_lu_free(task, iss);
4429 4429 rw_exit(iss->iss_lockp);
4430 4430 }
4431 4431
4432 4432 void
4433 4433 stmf_post_task(scsi_task_t *task, stmf_data_buf_t *dbuf)
4434 4434 {
4435 4435 stmf_i_scsi_task_t *itask = (stmf_i_scsi_task_t *)
4436 4436 task->task_stmf_private;
4437 4437 stmf_i_lu_t *ilu = (stmf_i_lu_t *)task->task_lu->lu_stmf_private;
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
4438 4438 int nv;
4439 4439 uint32_t old, new;
4440 4440 uint32_t ct;
4441 4441 stmf_worker_t *w, *w1;
4442 4442 uint8_t tm;
4443 4443
4444 4444 if (task->task_max_nbufs > 4)
4445 4445 task->task_max_nbufs = 4;
4446 4446 task->task_cur_nbufs = 0;
4447 4447 /* Latest value of currently running tasks */
4448 - ct = atomic_add_32_nv(&stmf_cur_ntasks, 1);
4448 + ct = atomic_inc_32_nv(&stmf_cur_ntasks);
4449 4449
4450 4450 /* Select the next worker using round robin */
4451 - nv = (int)atomic_add_32_nv((uint32_t *)&stmf_worker_sel_counter, 1);
4451 + nv = (int)atomic_inc_32_nv((uint32_t *)&stmf_worker_sel_counter);
4452 4452 if (nv >= stmf_nworkers_accepting_cmds) {
4453 4453 int s = nv;
4454 4454 do {
4455 4455 nv -= stmf_nworkers_accepting_cmds;
4456 4456 } while (nv >= stmf_nworkers_accepting_cmds);
4457 4457 if (nv < 0)
4458 4458 nv = 0;
4459 4459 /* Its ok if this cas fails */
4460 4460 (void) atomic_cas_32((uint32_t *)&stmf_worker_sel_counter,
4461 4461 s, nv);
4462 4462 }
4463 4463 w = &stmf_workers[nv];
4464 4464
4465 4465 /*
4466 4466 * A worker can be pinned by interrupt. So select the next one
4467 4467 * if it has lower load.
4468 4468 */
4469 4469 if ((nv + 1) >= stmf_nworkers_accepting_cmds) {
4470 4470 w1 = stmf_workers;
4471 4471 } else {
4472 4472 w1 = &stmf_workers[nv + 1];
4473 4473 }
4474 4474 if (w1->worker_queue_depth < w->worker_queue_depth)
4475 4475 w = w1;
4476 4476
4477 4477 mutex_enter(&w->worker_lock);
4478 4478 if (((w->worker_flags & STMF_WORKER_STARTED) == 0) ||
4479 4479 (w->worker_flags & STMF_WORKER_TERMINATE)) {
4480 4480 /*
4481 4481 * Maybe we are in the middle of a change. Just go to
4482 4482 * the 1st worker.
4483 4483 */
4484 4484 mutex_exit(&w->worker_lock);
4485 4485 w = stmf_workers;
4486 4486 mutex_enter(&w->worker_lock);
4487 4487 }
4488 4488 itask->itask_worker = w;
4489 4489 /*
4490 4490 * Track max system load inside the worker as we already have the
4491 4491 * worker lock (no point implementing another lock). The service
4492 4492 * thread will do the comparisons and figure out the max overall
4493 4493 * system load.
4494 4494 */
4495 4495 if (w->worker_max_sys_qdepth_pu < ct)
4496 4496 w->worker_max_sys_qdepth_pu = ct;
4497 4497
4498 4498 do {
4499 4499 old = new = itask->itask_flags;
4500 4500 new |= ITASK_KNOWN_TO_TGT_PORT | ITASK_IN_WORKER_QUEUE;
4501 4501 if (task->task_mgmt_function) {
4502 4502 tm = task->task_mgmt_function;
4503 4503 if ((tm == TM_TARGET_RESET) ||
4504 4504 (tm == TM_TARGET_COLD_RESET) ||
4505 4505 (tm == TM_TARGET_WARM_RESET)) {
4506 4506 new |= ITASK_DEFAULT_HANDLING;
4507 4507 }
4508 4508 } else if (task->task_cdb[0] == SCMD_REPORT_LUNS) {
4509 4509 new |= ITASK_DEFAULT_HANDLING;
4510 4510 }
4511 4511 new &= ~ITASK_IN_TRANSITION;
4512 4512 } while (atomic_cas_32(&itask->itask_flags, old, new) != old);
4513 4513
4514 4514 stmf_itl_task_start(itask);
4515 4515
4516 4516 itask->itask_worker_next = NULL;
4517 4517 if (w->worker_task_tail) {
|
↓ open down ↓ |
56 lines elided |
↑ open up ↑ |
4518 4518 w->worker_task_tail->itask_worker_next = itask;
4519 4519 } else {
4520 4520 w->worker_task_head = itask;
4521 4521 }
4522 4522 w->worker_task_tail = itask;
4523 4523 if (++(w->worker_queue_depth) > w->worker_max_qdepth_pu) {
4524 4524 w->worker_max_qdepth_pu = w->worker_queue_depth;
4525 4525 }
4526 4526 /* Measure task waitq time */
4527 4527 itask->itask_waitq_enter_timestamp = gethrtime();
4528 - atomic_add_32(&w->worker_ref_count, 1);
4528 + atomic_inc_32(&w->worker_ref_count);
4529 4529 itask->itask_cmd_stack[0] = ITASK_CMD_NEW_TASK;
4530 4530 itask->itask_ncmds = 1;
4531 4531 stmf_task_audit(itask, TE_TASK_START, CMD_OR_IOF_NA, dbuf);
4532 4532 if (dbuf) {
4533 4533 itask->itask_allocated_buf_map = 1;
4534 4534 itask->itask_dbufs[0] = dbuf;
4535 4535 dbuf->db_handle = 0;
4536 4536 } else {
4537 4537 itask->itask_allocated_buf_map = 0;
4538 4538 itask->itask_dbufs[0] = NULL;
4539 4539 }
4540 4540
4541 4541 if ((w->worker_flags & STMF_WORKER_ACTIVE) == 0) {
4542 4542 w->worker_signal_timestamp = gethrtime();
4543 4543 DTRACE_PROBE2(worker__signal, stmf_worker_t *, w,
4544 4544 scsi_task_t *, task);
4545 4545 cv_signal(&w->worker_cv);
4546 4546 }
4547 4547 mutex_exit(&w->worker_lock);
4548 4548
4549 4549 /*
4550 4550 * This can only happen if during stmf_task_alloc(), ILU_RESET_ACTIVE
4551 4551 * was set between checking of ILU_RESET_ACTIVE and clearing of the
4552 4552 * ITASK_IN_FREE_LIST flag. Take care of these "sneaked-in" tasks here.
4553 4553 */
4554 4554 if (ilu->ilu_flags & ILU_RESET_ACTIVE) {
4555 4555 stmf_abort(STMF_QUEUE_TASK_ABORT, task, STMF_ABORTED, NULL);
4556 4556 }
4557 4557 }
4558 4558
4559 4559 static void
4560 4560 stmf_task_audit(stmf_i_scsi_task_t *itask,
4561 4561 task_audit_event_t te, uint32_t cmd_or_iof, stmf_data_buf_t *dbuf)
4562 4562 {
4563 4563 stmf_task_audit_rec_t *ar;
4564 4564
4565 4565 mutex_enter(&itask->itask_audit_mutex);
4566 4566 ar = &itask->itask_audit_records[itask->itask_audit_index++];
4567 4567 itask->itask_audit_index &= (ITASK_TASK_AUDIT_DEPTH - 1);
4568 4568 ar->ta_event = te;
4569 4569 ar->ta_cmd_or_iof = cmd_or_iof;
4570 4570 ar->ta_itask_flags = itask->itask_flags;
4571 4571 ar->ta_dbuf = dbuf;
4572 4572 gethrestime(&ar->ta_timestamp);
4573 4573 mutex_exit(&itask->itask_audit_mutex);
4574 4574 }
4575 4575
4576 4576
4577 4577 /*
4578 4578 * ++++++++++++++ ABORT LOGIC ++++++++++++++++++++
4579 4579 * Once ITASK_BEING_ABORTED is set, ITASK_KNOWN_TO_LU can be reset already
4580 4580 * i.e. before ITASK_BEING_ABORTED being set. But if it was not, it cannot
4581 4581 * be reset until the LU explicitly calls stmf_task_lu_aborted(). Of course
4582 4582 * the LU will make this call only if we call the LU's abort entry point.
4583 4583 * we will only call that entry point if ITASK_KNOWN_TO_LU was set.
4584 4584 *
4585 4585 * Same logic applies for the port.
4586 4586 *
4587 4587 * Also ITASK_BEING_ABORTED will not be allowed to set if both KNOWN_TO_LU
4588 4588 * and KNOWN_TO_TGT_PORT are reset.
4589 4589 *
4590 4590 * +++++++++++++++++++++++++++++++++++++++++++++++
4591 4591 */
4592 4592
4593 4593 stmf_status_t
4594 4594 stmf_xfer_data(scsi_task_t *task, stmf_data_buf_t *dbuf, uint32_t ioflags)
4595 4595 {
4596 4596 stmf_status_t ret = STMF_SUCCESS;
4597 4597
4598 4598 stmf_i_scsi_task_t *itask =
4599 4599 (stmf_i_scsi_task_t *)task->task_stmf_private;
4600 4600
4601 4601 stmf_task_audit(itask, TE_XFER_START, ioflags, dbuf);
4602 4602
4603 4603 if (ioflags & STMF_IOF_LU_DONE) {
4604 4604 uint32_t new, old;
4605 4605 do {
|
↓ open down ↓ |
67 lines elided |
↑ open up ↑ |
4606 4606 new = old = itask->itask_flags;
4607 4607 if (new & ITASK_BEING_ABORTED)
4608 4608 return (STMF_ABORTED);
4609 4609 new &= ~ITASK_KNOWN_TO_LU;
4610 4610 } while (atomic_cas_32(&itask->itask_flags, old, new) != old);
4611 4611 }
4612 4612 if (itask->itask_flags & ITASK_BEING_ABORTED)
4613 4613 return (STMF_ABORTED);
4614 4614 #ifdef DEBUG
4615 4615 if (!(ioflags & STMF_IOF_STATS_ONLY) && stmf_drop_buf_counter > 0) {
4616 - if (atomic_add_32_nv((uint32_t *)&stmf_drop_buf_counter, -1) ==
4616 + if (atomic_dec_32_nv((uint32_t *)&stmf_drop_buf_counter) ==
4617 4617 1)
4618 4618 return (STMF_SUCCESS);
4619 4619 }
4620 4620 #endif
4621 4621
4622 4622 stmf_update_kstat_lu_io(task, dbuf);
4623 4623 stmf_update_kstat_lport_io(task, dbuf);
4624 4624 stmf_lport_xfer_start(itask, dbuf);
4625 4625 if (ioflags & STMF_IOF_STATS_ONLY) {
4626 4626 stmf_lport_xfer_done(itask, dbuf);
4627 4627 return (STMF_SUCCESS);
4628 4628 }
4629 4629
4630 4630 dbuf->db_flags |= DB_LPORT_XFER_ACTIVE;
4631 4631 ret = task->task_lport->lport_xfer_data(task, dbuf, ioflags);
4632 4632
4633 4633 /*
4634 4634 * Port provider may have already called the buffer callback in
4635 4635 * which case dbuf->db_xfer_start_timestamp will be 0.
4636 4636 */
4637 4637 if (ret != STMF_SUCCESS) {
4638 4638 dbuf->db_flags &= ~DB_LPORT_XFER_ACTIVE;
4639 4639 if (dbuf->db_xfer_start_timestamp != 0)
4640 4640 stmf_lport_xfer_done(itask, dbuf);
4641 4641 }
4642 4642
4643 4643 return (ret);
4644 4644 }
4645 4645
4646 4646 void
4647 4647 stmf_data_xfer_done(scsi_task_t *task, stmf_data_buf_t *dbuf, uint32_t iof)
4648 4648 {
4649 4649 stmf_i_scsi_task_t *itask =
4650 4650 (stmf_i_scsi_task_t *)task->task_stmf_private;
4651 4651 stmf_i_local_port_t *ilport;
4652 4652 stmf_worker_t *w = itask->itask_worker;
4653 4653 uint32_t new, old;
4654 4654 uint8_t update_queue_flags, free_it, queue_it;
4655 4655
4656 4656 stmf_lport_xfer_done(itask, dbuf);
4657 4657
4658 4658 stmf_task_audit(itask, TE_XFER_DONE, iof, dbuf);
4659 4659
4660 4660 /* Guard against unexpected completions from the lport */
4661 4661 if (dbuf->db_flags & DB_LPORT_XFER_ACTIVE) {
4662 4662 dbuf->db_flags &= ~DB_LPORT_XFER_ACTIVE;
4663 4663 } else {
4664 4664 /*
4665 4665 * This should never happen.
4666 4666 */
4667 4667 ilport = task->task_lport->lport_stmf_private;
4668 4668 ilport->ilport_unexpected_comp++;
4669 4669 cmn_err(CE_PANIC, "Unexpected xfer completion task %p dbuf %p",
4670 4670 (void *)task, (void *)dbuf);
4671 4671 return;
4672 4672 }
4673 4673
4674 4674 mutex_enter(&w->worker_lock);
4675 4675 do {
4676 4676 new = old = itask->itask_flags;
4677 4677 if (old & ITASK_BEING_ABORTED) {
4678 4678 mutex_exit(&w->worker_lock);
4679 4679 return;
4680 4680 }
4681 4681 free_it = 0;
4682 4682 if (iof & STMF_IOF_LPORT_DONE) {
4683 4683 new &= ~ITASK_KNOWN_TO_TGT_PORT;
4684 4684 task->task_completion_status = dbuf->db_xfer_status;
4685 4685 free_it = 1;
4686 4686 }
4687 4687 /*
4688 4688 * If the task is known to LU then queue it. But if
4689 4689 * it is already queued (multiple completions) then
4690 4690 * just update the buffer information by grabbing the
4691 4691 * worker lock. If the task is not known to LU,
4692 4692 * completed/aborted, then see if we need to
4693 4693 * free this task.
4694 4694 */
4695 4695 if (old & ITASK_KNOWN_TO_LU) {
4696 4696 free_it = 0;
4697 4697 update_queue_flags = 1;
4698 4698 if (old & ITASK_IN_WORKER_QUEUE) {
4699 4699 queue_it = 0;
4700 4700 } else {
4701 4701 queue_it = 1;
4702 4702 new |= ITASK_IN_WORKER_QUEUE;
4703 4703 }
4704 4704 } else {
4705 4705 update_queue_flags = 0;
4706 4706 queue_it = 0;
4707 4707 }
4708 4708 } while (atomic_cas_32(&itask->itask_flags, old, new) != old);
4709 4709
4710 4710 if (update_queue_flags) {
4711 4711 uint8_t cmd = (dbuf->db_handle << 5) | ITASK_CMD_DATA_XFER_DONE;
4712 4712
4713 4713 ASSERT(itask->itask_ncmds < ITASK_MAX_NCMDS);
4714 4714 itask->itask_cmd_stack[itask->itask_ncmds++] = cmd;
4715 4715 if (queue_it) {
4716 4716 itask->itask_worker_next = NULL;
4717 4717 if (w->worker_task_tail) {
4718 4718 w->worker_task_tail->itask_worker_next = itask;
4719 4719 } else {
4720 4720 w->worker_task_head = itask;
4721 4721 }
4722 4722 w->worker_task_tail = itask;
4723 4723 /* Measure task waitq time */
4724 4724 itask->itask_waitq_enter_timestamp = gethrtime();
4725 4725 if (++(w->worker_queue_depth) >
4726 4726 w->worker_max_qdepth_pu) {
4727 4727 w->worker_max_qdepth_pu = w->worker_queue_depth;
4728 4728 }
4729 4729 if ((w->worker_flags & STMF_WORKER_ACTIVE) == 0)
4730 4730 cv_signal(&w->worker_cv);
4731 4731 }
4732 4732 }
4733 4733 mutex_exit(&w->worker_lock);
4734 4734
4735 4735 if (free_it) {
4736 4736 if ((itask->itask_flags & (ITASK_KNOWN_TO_LU |
4737 4737 ITASK_KNOWN_TO_TGT_PORT | ITASK_IN_WORKER_QUEUE |
4738 4738 ITASK_BEING_ABORTED)) == 0) {
4739 4739 stmf_task_free(task);
4740 4740 }
4741 4741 }
4742 4742 }
4743 4743
4744 4744 stmf_status_t
4745 4745 stmf_send_scsi_status(scsi_task_t *task, uint32_t ioflags)
4746 4746 {
4747 4747 DTRACE_PROBE1(scsi__send__status, scsi_task_t *, task);
4748 4748
4749 4749 stmf_i_scsi_task_t *itask =
4750 4750 (stmf_i_scsi_task_t *)task->task_stmf_private;
4751 4751
4752 4752 stmf_task_audit(itask, TE_SEND_STATUS, ioflags, NULL);
4753 4753
4754 4754 if (ioflags & STMF_IOF_LU_DONE) {
4755 4755 uint32_t new, old;
4756 4756 do {
4757 4757 new = old = itask->itask_flags;
4758 4758 if (new & ITASK_BEING_ABORTED)
4759 4759 return (STMF_ABORTED);
4760 4760 new &= ~ITASK_KNOWN_TO_LU;
4761 4761 } while (atomic_cas_32(&itask->itask_flags, old, new) != old);
4762 4762 }
4763 4763
4764 4764 if (!(itask->itask_flags & ITASK_KNOWN_TO_TGT_PORT)) {
4765 4765 return (STMF_SUCCESS);
4766 4766 }
4767 4767
4768 4768 if (itask->itask_flags & ITASK_BEING_ABORTED)
4769 4769 return (STMF_ABORTED);
4770 4770
4771 4771 if (task->task_additional_flags & TASK_AF_NO_EXPECTED_XFER_LENGTH) {
4772 4772 task->task_status_ctrl = 0;
4773 4773 task->task_resid = 0;
4774 4774 } else if (task->task_cmd_xfer_length >
4775 4775 task->task_expected_xfer_length) {
4776 4776 task->task_status_ctrl = TASK_SCTRL_OVER;
4777 4777 task->task_resid = task->task_cmd_xfer_length -
4778 4778 task->task_expected_xfer_length;
4779 4779 } else if (task->task_nbytes_transferred <
4780 4780 task->task_expected_xfer_length) {
4781 4781 task->task_status_ctrl = TASK_SCTRL_UNDER;
4782 4782 task->task_resid = task->task_expected_xfer_length -
4783 4783 task->task_nbytes_transferred;
4784 4784 } else {
4785 4785 task->task_status_ctrl = 0;
4786 4786 task->task_resid = 0;
4787 4787 }
4788 4788 return (task->task_lport->lport_send_status(task, ioflags));
4789 4789 }
4790 4790
4791 4791 void
4792 4792 stmf_send_status_done(scsi_task_t *task, stmf_status_t s, uint32_t iof)
4793 4793 {
4794 4794 stmf_i_scsi_task_t *itask =
4795 4795 (stmf_i_scsi_task_t *)task->task_stmf_private;
4796 4796 stmf_worker_t *w = itask->itask_worker;
4797 4797 uint32_t new, old;
4798 4798 uint8_t free_it, queue_it;
4799 4799
4800 4800 stmf_task_audit(itask, TE_SEND_STATUS_DONE, iof, NULL);
4801 4801
4802 4802 mutex_enter(&w->worker_lock);
4803 4803 do {
4804 4804 new = old = itask->itask_flags;
4805 4805 if (old & ITASK_BEING_ABORTED) {
4806 4806 mutex_exit(&w->worker_lock);
4807 4807 return;
4808 4808 }
4809 4809 free_it = 0;
4810 4810 if (iof & STMF_IOF_LPORT_DONE) {
4811 4811 new &= ~ITASK_KNOWN_TO_TGT_PORT;
4812 4812 free_it = 1;
4813 4813 }
4814 4814 /*
4815 4815 * If the task is known to LU then queue it. But if
4816 4816 * it is already queued (multiple completions) then
4817 4817 * just update the buffer information by grabbing the
4818 4818 * worker lock. If the task is not known to LU,
4819 4819 * completed/aborted, then see if we need to
4820 4820 * free this task.
4821 4821 */
4822 4822 if (old & ITASK_KNOWN_TO_LU) {
4823 4823 free_it = 0;
4824 4824 queue_it = 1;
4825 4825 if (old & ITASK_IN_WORKER_QUEUE) {
4826 4826 cmn_err(CE_PANIC, "status completion received"
4827 4827 " when task is already in worker queue "
4828 4828 " task = %p", (void *)task);
4829 4829 }
4830 4830 new |= ITASK_IN_WORKER_QUEUE;
4831 4831 } else {
4832 4832 queue_it = 0;
4833 4833 }
4834 4834 } while (atomic_cas_32(&itask->itask_flags, old, new) != old);
4835 4835 task->task_completion_status = s;
4836 4836
4837 4837
4838 4838 if (queue_it) {
4839 4839 ASSERT(itask->itask_ncmds < ITASK_MAX_NCMDS);
4840 4840 itask->itask_cmd_stack[itask->itask_ncmds++] =
4841 4841 ITASK_CMD_STATUS_DONE;
4842 4842 itask->itask_worker_next = NULL;
4843 4843 if (w->worker_task_tail) {
4844 4844 w->worker_task_tail->itask_worker_next = itask;
4845 4845 } else {
4846 4846 w->worker_task_head = itask;
4847 4847 }
4848 4848 w->worker_task_tail = itask;
4849 4849 /* Measure task waitq time */
4850 4850 itask->itask_waitq_enter_timestamp = gethrtime();
4851 4851 if (++(w->worker_queue_depth) > w->worker_max_qdepth_pu) {
4852 4852 w->worker_max_qdepth_pu = w->worker_queue_depth;
4853 4853 }
4854 4854 if ((w->worker_flags & STMF_WORKER_ACTIVE) == 0)
4855 4855 cv_signal(&w->worker_cv);
4856 4856 }
4857 4857 mutex_exit(&w->worker_lock);
4858 4858
4859 4859 if (free_it) {
4860 4860 if ((itask->itask_flags & (ITASK_KNOWN_TO_LU |
4861 4861 ITASK_KNOWN_TO_TGT_PORT | ITASK_IN_WORKER_QUEUE |
4862 4862 ITASK_BEING_ABORTED)) == 0) {
4863 4863 stmf_task_free(task);
4864 4864 } else {
4865 4865 cmn_err(CE_PANIC, "LU is done with the task but LPORT "
4866 4866 " is not done, itask %p itask_flags %x",
4867 4867 (void *)itask, itask->itask_flags);
4868 4868 }
4869 4869 }
4870 4870 }
4871 4871
4872 4872 void
4873 4873 stmf_task_lu_done(scsi_task_t *task)
4874 4874 {
4875 4875 stmf_i_scsi_task_t *itask =
4876 4876 (stmf_i_scsi_task_t *)task->task_stmf_private;
4877 4877 stmf_worker_t *w = itask->itask_worker;
4878 4878 uint32_t new, old;
4879 4879
4880 4880 mutex_enter(&w->worker_lock);
4881 4881 do {
4882 4882 new = old = itask->itask_flags;
4883 4883 if (old & ITASK_BEING_ABORTED) {
4884 4884 mutex_exit(&w->worker_lock);
4885 4885 return;
4886 4886 }
4887 4887 if (old & ITASK_IN_WORKER_QUEUE) {
4888 4888 cmn_err(CE_PANIC, "task_lu_done received"
4889 4889 " when task is in worker queue "
4890 4890 " task = %p", (void *)task);
4891 4891 }
4892 4892 new &= ~ITASK_KNOWN_TO_LU;
4893 4893 } while (atomic_cas_32(&itask->itask_flags, old, new) != old);
4894 4894
4895 4895 mutex_exit(&w->worker_lock);
4896 4896
4897 4897 if ((itask->itask_flags & (ITASK_KNOWN_TO_LU |
4898 4898 ITASK_KNOWN_TO_TGT_PORT | ITASK_IN_WORKER_QUEUE |
4899 4899 ITASK_BEING_ABORTED)) == 0) {
4900 4900 stmf_task_free(task);
4901 4901 } else {
4902 4902 cmn_err(CE_PANIC, "stmf_lu_done should be the last stage but "
4903 4903 " the task is still not done, task = %p", (void *)task);
4904 4904 }
4905 4905 }
4906 4906
4907 4907 void
4908 4908 stmf_queue_task_for_abort(scsi_task_t *task, stmf_status_t s)
4909 4909 {
4910 4910 stmf_i_scsi_task_t *itask =
4911 4911 (stmf_i_scsi_task_t *)task->task_stmf_private;
4912 4912 stmf_worker_t *w;
4913 4913 uint32_t old, new;
4914 4914
4915 4915 stmf_task_audit(itask, TE_TASK_ABORT, CMD_OR_IOF_NA, NULL);
4916 4916
4917 4917 do {
4918 4918 old = new = itask->itask_flags;
4919 4919 if ((old & ITASK_BEING_ABORTED) ||
4920 4920 ((old & (ITASK_KNOWN_TO_TGT_PORT |
4921 4921 ITASK_KNOWN_TO_LU)) == 0)) {
4922 4922 return;
4923 4923 }
4924 4924 new |= ITASK_BEING_ABORTED;
4925 4925 } while (atomic_cas_32(&itask->itask_flags, old, new) != old);
4926 4926 task->task_completion_status = s;
4927 4927 itask->itask_start_time = ddi_get_lbolt();
4928 4928
4929 4929 if (((w = itask->itask_worker) == NULL) ||
4930 4930 (itask->itask_flags & ITASK_IN_TRANSITION)) {
4931 4931 return;
4932 4932 }
4933 4933
4934 4934 /* Queue it and get out */
4935 4935 mutex_enter(&w->worker_lock);
4936 4936 if (itask->itask_flags & ITASK_IN_WORKER_QUEUE) {
4937 4937 mutex_exit(&w->worker_lock);
4938 4938 return;
4939 4939 }
4940 4940 atomic_or_32(&itask->itask_flags, ITASK_IN_WORKER_QUEUE);
4941 4941 itask->itask_worker_next = NULL;
4942 4942 if (w->worker_task_tail) {
4943 4943 w->worker_task_tail->itask_worker_next = itask;
4944 4944 } else {
4945 4945 w->worker_task_head = itask;
4946 4946 }
4947 4947 w->worker_task_tail = itask;
4948 4948 if (++(w->worker_queue_depth) > w->worker_max_qdepth_pu) {
4949 4949 w->worker_max_qdepth_pu = w->worker_queue_depth;
4950 4950 }
4951 4951 if ((w->worker_flags & STMF_WORKER_ACTIVE) == 0)
4952 4952 cv_signal(&w->worker_cv);
4953 4953 mutex_exit(&w->worker_lock);
4954 4954 }
4955 4955
4956 4956 void
4957 4957 stmf_abort(int abort_cmd, scsi_task_t *task, stmf_status_t s, void *arg)
4958 4958 {
4959 4959 stmf_i_scsi_task_t *itask = NULL;
4960 4960 uint32_t old, new, f, rf;
4961 4961
4962 4962 DTRACE_PROBE2(scsi__task__abort, scsi_task_t *, task,
4963 4963 stmf_status_t, s);
4964 4964
4965 4965 switch (abort_cmd) {
4966 4966 case STMF_QUEUE_ABORT_LU:
4967 4967 stmf_task_lu_killall((stmf_lu_t *)arg, task, s);
4968 4968 return;
4969 4969 case STMF_QUEUE_TASK_ABORT:
4970 4970 stmf_queue_task_for_abort(task, s);
4971 4971 return;
4972 4972 case STMF_REQUEUE_TASK_ABORT_LPORT:
4973 4973 rf = ITASK_TGT_PORT_ABORT_CALLED;
4974 4974 f = ITASK_KNOWN_TO_TGT_PORT;
4975 4975 break;
4976 4976 case STMF_REQUEUE_TASK_ABORT_LU:
4977 4977 rf = ITASK_LU_ABORT_CALLED;
4978 4978 f = ITASK_KNOWN_TO_LU;
4979 4979 break;
4980 4980 default:
4981 4981 return;
4982 4982 }
4983 4983 itask = (stmf_i_scsi_task_t *)task->task_stmf_private;
4984 4984 f |= ITASK_BEING_ABORTED | rf;
4985 4985 do {
4986 4986 old = new = itask->itask_flags;
4987 4987 if ((old & f) != f) {
4988 4988 return;
4989 4989 }
4990 4990 new &= ~rf;
4991 4991 } while (atomic_cas_32(&itask->itask_flags, old, new) != old);
4992 4992 }
4993 4993
4994 4994 void
4995 4995 stmf_task_lu_aborted(scsi_task_t *task, stmf_status_t s, uint32_t iof)
4996 4996 {
4997 4997 char info[STMF_CHANGE_INFO_LEN];
4998 4998 stmf_i_scsi_task_t *itask = TASK_TO_ITASK(task);
4999 4999 unsigned long long st;
5000 5000
5001 5001 stmf_task_audit(itask, TE_TASK_LU_ABORTED, iof, NULL);
5002 5002
5003 5003 st = s; /* gcc fix */
5004 5004 if ((s != STMF_ABORT_SUCCESS) && (s != STMF_NOT_FOUND)) {
5005 5005 (void) snprintf(info, sizeof (info),
5006 5006 "task %p, lu failed to abort ret=%llx", (void *)task, st);
5007 5007 } else if ((iof & STMF_IOF_LU_DONE) == 0) {
5008 5008 (void) snprintf(info, sizeof (info),
5009 5009 "Task aborted but LU is not finished, task ="
5010 5010 "%p, s=%llx, iof=%x", (void *)task, st, iof);
5011 5011 } else {
5012 5012 /*
5013 5013 * LU abort successfully
5014 5014 */
5015 5015 atomic_and_32(&itask->itask_flags, ~ITASK_KNOWN_TO_LU);
5016 5016 return;
5017 5017 }
5018 5018
5019 5019 stmf_abort_task_offline(task, 1, info);
5020 5020 }
5021 5021
5022 5022 void
5023 5023 stmf_task_lport_aborted(scsi_task_t *task, stmf_status_t s, uint32_t iof)
5024 5024 {
5025 5025 char info[STMF_CHANGE_INFO_LEN];
5026 5026 stmf_i_scsi_task_t *itask = TASK_TO_ITASK(task);
5027 5027 unsigned long long st;
5028 5028 uint32_t old, new;
5029 5029
5030 5030 stmf_task_audit(itask, TE_TASK_LPORT_ABORTED, iof, NULL);
5031 5031
5032 5032 st = s;
5033 5033 if ((s != STMF_ABORT_SUCCESS) && (s != STMF_NOT_FOUND)) {
5034 5034 (void) snprintf(info, sizeof (info),
5035 5035 "task %p, tgt port failed to abort ret=%llx", (void *)task,
5036 5036 st);
5037 5037 } else if ((iof & STMF_IOF_LPORT_DONE) == 0) {
5038 5038 (void) snprintf(info, sizeof (info),
5039 5039 "Task aborted but tgt port is not finished, "
5040 5040 "task=%p, s=%llx, iof=%x", (void *)task, st, iof);
5041 5041 } else {
5042 5042 /*
5043 5043 * LPORT abort successfully
5044 5044 */
5045 5045 do {
5046 5046 old = new = itask->itask_flags;
5047 5047 if (!(old & ITASK_KNOWN_TO_TGT_PORT))
5048 5048 return;
5049 5049 new &= ~ITASK_KNOWN_TO_TGT_PORT;
5050 5050 } while (atomic_cas_32(&itask->itask_flags, old, new) != old);
5051 5051 return;
5052 5052 }
5053 5053
5054 5054 stmf_abort_task_offline(task, 0, info);
5055 5055 }
5056 5056
5057 5057 stmf_status_t
5058 5058 stmf_task_poll_lu(scsi_task_t *task, uint32_t timeout)
5059 5059 {
5060 5060 stmf_i_scsi_task_t *itask = (stmf_i_scsi_task_t *)
5061 5061 task->task_stmf_private;
5062 5062 stmf_worker_t *w = itask->itask_worker;
5063 5063 int i;
5064 5064
5065 5065 ASSERT(itask->itask_flags & ITASK_KNOWN_TO_LU);
5066 5066 mutex_enter(&w->worker_lock);
5067 5067 if (itask->itask_ncmds >= ITASK_MAX_NCMDS) {
5068 5068 mutex_exit(&w->worker_lock);
5069 5069 return (STMF_BUSY);
5070 5070 }
5071 5071 for (i = 0; i < itask->itask_ncmds; i++) {
5072 5072 if (itask->itask_cmd_stack[i] == ITASK_CMD_POLL_LU) {
5073 5073 mutex_exit(&w->worker_lock);
5074 5074 return (STMF_SUCCESS);
5075 5075 }
5076 5076 }
5077 5077 itask->itask_cmd_stack[itask->itask_ncmds++] = ITASK_CMD_POLL_LU;
5078 5078 if (timeout == ITASK_DEFAULT_POLL_TIMEOUT) {
5079 5079 itask->itask_poll_timeout = ddi_get_lbolt() + 1;
5080 5080 } else {
5081 5081 clock_t t = drv_usectohz(timeout * 1000);
5082 5082 if (t == 0)
5083 5083 t = 1;
5084 5084 itask->itask_poll_timeout = ddi_get_lbolt() + t;
5085 5085 }
5086 5086 if ((itask->itask_flags & ITASK_IN_WORKER_QUEUE) == 0) {
5087 5087 itask->itask_worker_next = NULL;
5088 5088 if (w->worker_task_tail) {
5089 5089 w->worker_task_tail->itask_worker_next = itask;
5090 5090 } else {
5091 5091 w->worker_task_head = itask;
5092 5092 }
5093 5093 w->worker_task_tail = itask;
5094 5094 if (++(w->worker_queue_depth) > w->worker_max_qdepth_pu) {
5095 5095 w->worker_max_qdepth_pu = w->worker_queue_depth;
5096 5096 }
5097 5097 atomic_or_32(&itask->itask_flags, ITASK_IN_WORKER_QUEUE);
5098 5098 if ((w->worker_flags & STMF_WORKER_ACTIVE) == 0)
5099 5099 cv_signal(&w->worker_cv);
5100 5100 }
5101 5101 mutex_exit(&w->worker_lock);
5102 5102 return (STMF_SUCCESS);
5103 5103 }
5104 5104
5105 5105 stmf_status_t
5106 5106 stmf_task_poll_lport(scsi_task_t *task, uint32_t timeout)
5107 5107 {
5108 5108 stmf_i_scsi_task_t *itask = (stmf_i_scsi_task_t *)
5109 5109 task->task_stmf_private;
5110 5110 stmf_worker_t *w = itask->itask_worker;
5111 5111 int i;
5112 5112
5113 5113 ASSERT(itask->itask_flags & ITASK_KNOWN_TO_TGT_PORT);
5114 5114 mutex_enter(&w->worker_lock);
5115 5115 if (itask->itask_ncmds >= ITASK_MAX_NCMDS) {
5116 5116 mutex_exit(&w->worker_lock);
5117 5117 return (STMF_BUSY);
5118 5118 }
5119 5119 for (i = 0; i < itask->itask_ncmds; i++) {
5120 5120 if (itask->itask_cmd_stack[i] == ITASK_CMD_POLL_LPORT) {
5121 5121 mutex_exit(&w->worker_lock);
5122 5122 return (STMF_SUCCESS);
5123 5123 }
5124 5124 }
5125 5125 itask->itask_cmd_stack[itask->itask_ncmds++] = ITASK_CMD_POLL_LPORT;
5126 5126 if (timeout == ITASK_DEFAULT_POLL_TIMEOUT) {
5127 5127 itask->itask_poll_timeout = ddi_get_lbolt() + 1;
5128 5128 } else {
5129 5129 clock_t t = drv_usectohz(timeout * 1000);
5130 5130 if (t == 0)
5131 5131 t = 1;
5132 5132 itask->itask_poll_timeout = ddi_get_lbolt() + t;
5133 5133 }
5134 5134 if ((itask->itask_flags & ITASK_IN_WORKER_QUEUE) == 0) {
5135 5135 itask->itask_worker_next = NULL;
5136 5136 if (w->worker_task_tail) {
5137 5137 w->worker_task_tail->itask_worker_next = itask;
5138 5138 } else {
5139 5139 w->worker_task_head = itask;
5140 5140 }
5141 5141 w->worker_task_tail = itask;
5142 5142 if (++(w->worker_queue_depth) > w->worker_max_qdepth_pu) {
5143 5143 w->worker_max_qdepth_pu = w->worker_queue_depth;
5144 5144 }
5145 5145 if ((w->worker_flags & STMF_WORKER_ACTIVE) == 0)
5146 5146 cv_signal(&w->worker_cv);
5147 5147 }
5148 5148 mutex_exit(&w->worker_lock);
5149 5149 return (STMF_SUCCESS);
5150 5150 }
5151 5151
5152 5152 void
5153 5153 stmf_do_task_abort(scsi_task_t *task)
5154 5154 {
5155 5155 stmf_i_scsi_task_t *itask = TASK_TO_ITASK(task);
5156 5156 stmf_lu_t *lu;
5157 5157 stmf_local_port_t *lport;
5158 5158 unsigned long long ret;
5159 5159 uint32_t old, new;
5160 5160 uint8_t call_lu_abort, call_port_abort;
5161 5161 char info[STMF_CHANGE_INFO_LEN];
5162 5162
5163 5163 lu = task->task_lu;
5164 5164 lport = task->task_lport;
5165 5165 do {
5166 5166 old = new = itask->itask_flags;
5167 5167 if ((old & (ITASK_KNOWN_TO_LU | ITASK_LU_ABORT_CALLED)) ==
5168 5168 ITASK_KNOWN_TO_LU) {
5169 5169 new |= ITASK_LU_ABORT_CALLED;
5170 5170 call_lu_abort = 1;
5171 5171 } else {
5172 5172 call_lu_abort = 0;
5173 5173 }
5174 5174 } while (atomic_cas_32(&itask->itask_flags, old, new) != old);
5175 5175
5176 5176 if (call_lu_abort) {
5177 5177 if ((itask->itask_flags & ITASK_DEFAULT_HANDLING) == 0) {
5178 5178 ret = lu->lu_abort(lu, STMF_LU_ABORT_TASK, task, 0);
5179 5179 } else {
5180 5180 ret = dlun0->lu_abort(lu, STMF_LU_ABORT_TASK, task, 0);
5181 5181 }
5182 5182 if ((ret == STMF_ABORT_SUCCESS) || (ret == STMF_NOT_FOUND)) {
5183 5183 stmf_task_lu_aborted(task, ret, STMF_IOF_LU_DONE);
5184 5184 } else if (ret == STMF_BUSY) {
5185 5185 atomic_and_32(&itask->itask_flags,
5186 5186 ~ITASK_LU_ABORT_CALLED);
5187 5187 } else if (ret != STMF_SUCCESS) {
5188 5188 (void) snprintf(info, sizeof (info),
5189 5189 "Abort failed by LU %p, ret %llx", (void *)lu, ret);
5190 5190 stmf_abort_task_offline(task, 1, info);
5191 5191 }
5192 5192 } else if (itask->itask_flags & ITASK_KNOWN_TO_LU) {
5193 5193 if (ddi_get_lbolt() > (itask->itask_start_time +
5194 5194 STMF_SEC2TICK(lu->lu_abort_timeout?
5195 5195 lu->lu_abort_timeout : ITASK_DEFAULT_ABORT_TIMEOUT))) {
5196 5196 (void) snprintf(info, sizeof (info),
5197 5197 "lu abort timed out");
5198 5198 stmf_abort_task_offline(itask->itask_task, 1, info);
5199 5199 }
5200 5200 }
5201 5201
5202 5202 do {
5203 5203 old = new = itask->itask_flags;
5204 5204 if ((old & (ITASK_KNOWN_TO_TGT_PORT |
5205 5205 ITASK_TGT_PORT_ABORT_CALLED)) == ITASK_KNOWN_TO_TGT_PORT) {
5206 5206 new |= ITASK_TGT_PORT_ABORT_CALLED;
5207 5207 call_port_abort = 1;
5208 5208 } else {
5209 5209 call_port_abort = 0;
5210 5210 }
5211 5211 } while (atomic_cas_32(&itask->itask_flags, old, new) != old);
5212 5212 if (call_port_abort) {
5213 5213 ret = lport->lport_abort(lport, STMF_LPORT_ABORT_TASK, task, 0);
5214 5214 if ((ret == STMF_ABORT_SUCCESS) || (ret == STMF_NOT_FOUND)) {
5215 5215 stmf_task_lport_aborted(task, ret, STMF_IOF_LPORT_DONE);
5216 5216 } else if (ret == STMF_BUSY) {
5217 5217 atomic_and_32(&itask->itask_flags,
5218 5218 ~ITASK_TGT_PORT_ABORT_CALLED);
5219 5219 } else if (ret != STMF_SUCCESS) {
5220 5220 (void) snprintf(info, sizeof (info),
5221 5221 "Abort failed by tgt port %p ret %llx",
5222 5222 (void *)lport, ret);
5223 5223 stmf_abort_task_offline(task, 0, info);
5224 5224 }
5225 5225 } else if (itask->itask_flags & ITASK_KNOWN_TO_TGT_PORT) {
5226 5226 if (ddi_get_lbolt() > (itask->itask_start_time +
5227 5227 STMF_SEC2TICK(lport->lport_abort_timeout?
5228 5228 lport->lport_abort_timeout :
5229 5229 ITASK_DEFAULT_ABORT_TIMEOUT))) {
5230 5230 (void) snprintf(info, sizeof (info),
5231 5231 "lport abort timed out");
5232 5232 stmf_abort_task_offline(itask->itask_task, 0, info);
5233 5233 }
5234 5234 }
5235 5235 }
5236 5236
5237 5237 stmf_status_t
5238 5238 stmf_ctl(int cmd, void *obj, void *arg)
5239 5239 {
5240 5240 stmf_status_t ret;
5241 5241 stmf_i_lu_t *ilu;
5242 5242 stmf_i_local_port_t *ilport;
5243 5243 stmf_state_change_info_t *ssci = (stmf_state_change_info_t *)arg;
5244 5244
5245 5245 mutex_enter(&stmf_state.stmf_lock);
5246 5246 ret = STMF_INVALID_ARG;
5247 5247 if (cmd & STMF_CMD_LU_OP) {
5248 5248 ilu = stmf_lookup_lu((stmf_lu_t *)obj);
5249 5249 if (ilu == NULL) {
5250 5250 goto stmf_ctl_lock_exit;
5251 5251 }
5252 5252 DTRACE_PROBE3(lu__state__change,
5253 5253 stmf_lu_t *, ilu->ilu_lu,
5254 5254 int, cmd, stmf_state_change_info_t *, ssci);
5255 5255 } else if (cmd & STMF_CMD_LPORT_OP) {
5256 5256 ilport = stmf_lookup_lport((stmf_local_port_t *)obj);
5257 5257 if (ilport == NULL) {
5258 5258 goto stmf_ctl_lock_exit;
5259 5259 }
5260 5260 DTRACE_PROBE3(lport__state__change,
5261 5261 stmf_local_port_t *, ilport->ilport_lport,
5262 5262 int, cmd, stmf_state_change_info_t *, ssci);
5263 5263 } else {
5264 5264 goto stmf_ctl_lock_exit;
5265 5265 }
5266 5266
5267 5267 switch (cmd) {
5268 5268 case STMF_CMD_LU_ONLINE:
5269 5269 switch (ilu->ilu_state) {
5270 5270 case STMF_STATE_OFFLINE:
5271 5271 ret = STMF_SUCCESS;
5272 5272 break;
5273 5273 case STMF_STATE_ONLINE:
5274 5274 case STMF_STATE_ONLINING:
5275 5275 ret = STMF_ALREADY;
5276 5276 break;
5277 5277 case STMF_STATE_OFFLINING:
5278 5278 ret = STMF_BUSY;
5279 5279 break;
5280 5280 default:
5281 5281 ret = STMF_BADSTATE;
5282 5282 break;
5283 5283 }
5284 5284 if (ret != STMF_SUCCESS)
5285 5285 goto stmf_ctl_lock_exit;
5286 5286
5287 5287 ilu->ilu_state = STMF_STATE_ONLINING;
5288 5288 mutex_exit(&stmf_state.stmf_lock);
5289 5289 stmf_svc_queue(cmd, obj, (stmf_state_change_info_t *)arg);
5290 5290 break;
5291 5291
5292 5292 case STMF_CMD_LU_ONLINE_COMPLETE:
5293 5293 if (ilu->ilu_state != STMF_STATE_ONLINING) {
5294 5294 ret = STMF_BADSTATE;
5295 5295 goto stmf_ctl_lock_exit;
5296 5296 }
5297 5297 if (((stmf_change_status_t *)arg)->st_completion_status ==
5298 5298 STMF_SUCCESS) {
5299 5299 ilu->ilu_state = STMF_STATE_ONLINE;
5300 5300 mutex_exit(&stmf_state.stmf_lock);
5301 5301 ((stmf_lu_t *)obj)->lu_ctl((stmf_lu_t *)obj,
5302 5302 STMF_ACK_LU_ONLINE_COMPLETE, arg);
5303 5303 mutex_enter(&stmf_state.stmf_lock);
5304 5304 stmf_add_lu_to_active_sessions((stmf_lu_t *)obj);
5305 5305 } else {
5306 5306 /* XXX: should throw a meesage an record more data */
5307 5307 ilu->ilu_state = STMF_STATE_OFFLINE;
5308 5308 }
5309 5309 ret = STMF_SUCCESS;
5310 5310 goto stmf_ctl_lock_exit;
5311 5311
5312 5312 case STMF_CMD_LU_OFFLINE:
5313 5313 switch (ilu->ilu_state) {
5314 5314 case STMF_STATE_ONLINE:
5315 5315 ret = STMF_SUCCESS;
5316 5316 break;
5317 5317 case STMF_STATE_OFFLINE:
5318 5318 case STMF_STATE_OFFLINING:
5319 5319 ret = STMF_ALREADY;
5320 5320 break;
5321 5321 case STMF_STATE_ONLINING:
5322 5322 ret = STMF_BUSY;
5323 5323 break;
5324 5324 default:
5325 5325 ret = STMF_BADSTATE;
5326 5326 break;
5327 5327 }
5328 5328 if (ret != STMF_SUCCESS)
5329 5329 goto stmf_ctl_lock_exit;
5330 5330 ilu->ilu_state = STMF_STATE_OFFLINING;
5331 5331 mutex_exit(&stmf_state.stmf_lock);
5332 5332 stmf_svc_queue(cmd, obj, (stmf_state_change_info_t *)arg);
5333 5333 break;
5334 5334
5335 5335 case STMF_CMD_LU_OFFLINE_COMPLETE:
5336 5336 if (ilu->ilu_state != STMF_STATE_OFFLINING) {
5337 5337 ret = STMF_BADSTATE;
5338 5338 goto stmf_ctl_lock_exit;
5339 5339 }
5340 5340 if (((stmf_change_status_t *)arg)->st_completion_status ==
5341 5341 STMF_SUCCESS) {
5342 5342 ilu->ilu_state = STMF_STATE_OFFLINE;
5343 5343 mutex_exit(&stmf_state.stmf_lock);
5344 5344 ((stmf_lu_t *)obj)->lu_ctl((stmf_lu_t *)obj,
5345 5345 STMF_ACK_LU_OFFLINE_COMPLETE, arg);
5346 5346 mutex_enter(&stmf_state.stmf_lock);
5347 5347 } else {
5348 5348 ilu->ilu_state = STMF_STATE_ONLINE;
5349 5349 stmf_add_lu_to_active_sessions((stmf_lu_t *)obj);
5350 5350 }
5351 5351 mutex_exit(&stmf_state.stmf_lock);
5352 5352 break;
5353 5353
5354 5354 /*
5355 5355 * LPORT_ONLINE/OFFLINE has nothing to do with link offline/online.
5356 5356 * It's related with hardware disable/enable.
5357 5357 */
5358 5358 case STMF_CMD_LPORT_ONLINE:
5359 5359 switch (ilport->ilport_state) {
5360 5360 case STMF_STATE_OFFLINE:
5361 5361 ret = STMF_SUCCESS;
5362 5362 break;
5363 5363 case STMF_STATE_ONLINE:
5364 5364 case STMF_STATE_ONLINING:
5365 5365 ret = STMF_ALREADY;
5366 5366 break;
5367 5367 case STMF_STATE_OFFLINING:
5368 5368 ret = STMF_BUSY;
5369 5369 break;
5370 5370 default:
5371 5371 ret = STMF_BADSTATE;
5372 5372 break;
5373 5373 }
5374 5374 if (ret != STMF_SUCCESS)
5375 5375 goto stmf_ctl_lock_exit;
5376 5376
5377 5377 /*
5378 5378 * Only user request can recover the port from the
5379 5379 * FORCED_OFFLINE state
5380 5380 */
5381 5381 if (ilport->ilport_flags & ILPORT_FORCED_OFFLINE) {
5382 5382 if (!(ssci->st_rflags & STMF_RFLAG_USER_REQUEST)) {
5383 5383 ret = STMF_FAILURE;
5384 5384 goto stmf_ctl_lock_exit;
5385 5385 }
5386 5386 }
5387 5387
5388 5388 /*
5389 5389 * Avoid too frequent request to online
5390 5390 */
5391 5391 if (ssci->st_rflags & STMF_RFLAG_USER_REQUEST) {
5392 5392 ilport->ilport_online_times = 0;
5393 5393 ilport->ilport_avg_interval = 0;
5394 5394 }
5395 5395 if ((ilport->ilport_avg_interval < STMF_AVG_ONLINE_INTERVAL) &&
5396 5396 (ilport->ilport_online_times >= 4)) {
5397 5397 ret = STMF_FAILURE;
5398 5398 ilport->ilport_flags |= ILPORT_FORCED_OFFLINE;
5399 5399 stmf_trace(NULL, "stmf_ctl: too frequent request to "
5400 5400 "online the port");
5401 5401 cmn_err(CE_WARN, "stmf_ctl: too frequent request to "
5402 5402 "online the port, set FORCED_OFFLINE now");
5403 5403 goto stmf_ctl_lock_exit;
5404 5404 }
5405 5405 if (ilport->ilport_online_times > 0) {
5406 5406 if (ilport->ilport_online_times == 1) {
5407 5407 ilport->ilport_avg_interval = ddi_get_lbolt() -
5408 5408 ilport->ilport_last_online_clock;
5409 5409 } else {
5410 5410 ilport->ilport_avg_interval =
5411 5411 (ilport->ilport_avg_interval +
5412 5412 ddi_get_lbolt() -
5413 5413 ilport->ilport_last_online_clock) >> 1;
5414 5414 }
5415 5415 }
5416 5416 ilport->ilport_last_online_clock = ddi_get_lbolt();
5417 5417 ilport->ilport_online_times++;
5418 5418
5419 5419 /*
5420 5420 * Submit online service request
5421 5421 */
5422 5422 ilport->ilport_flags &= ~ILPORT_FORCED_OFFLINE;
5423 5423 ilport->ilport_state = STMF_STATE_ONLINING;
5424 5424 mutex_exit(&stmf_state.stmf_lock);
5425 5425 stmf_svc_queue(cmd, obj, (stmf_state_change_info_t *)arg);
5426 5426 break;
5427 5427
5428 5428 case STMF_CMD_LPORT_ONLINE_COMPLETE:
5429 5429 if (ilport->ilport_state != STMF_STATE_ONLINING) {
5430 5430 ret = STMF_BADSTATE;
5431 5431 goto stmf_ctl_lock_exit;
5432 5432 }
5433 5433 if (((stmf_change_status_t *)arg)->st_completion_status ==
5434 5434 STMF_SUCCESS) {
5435 5435 ilport->ilport_state = STMF_STATE_ONLINE;
5436 5436 mutex_exit(&stmf_state.stmf_lock);
5437 5437 ((stmf_local_port_t *)obj)->lport_ctl(
5438 5438 (stmf_local_port_t *)obj,
5439 5439 STMF_ACK_LPORT_ONLINE_COMPLETE, arg);
5440 5440 mutex_enter(&stmf_state.stmf_lock);
5441 5441 } else {
5442 5442 ilport->ilport_state = STMF_STATE_OFFLINE;
5443 5443 }
5444 5444 ret = STMF_SUCCESS;
5445 5445 goto stmf_ctl_lock_exit;
5446 5446
5447 5447 case STMF_CMD_LPORT_OFFLINE:
5448 5448 switch (ilport->ilport_state) {
5449 5449 case STMF_STATE_ONLINE:
5450 5450 ret = STMF_SUCCESS;
5451 5451 break;
5452 5452 case STMF_STATE_OFFLINE:
5453 5453 case STMF_STATE_OFFLINING:
5454 5454 ret = STMF_ALREADY;
5455 5455 break;
5456 5456 case STMF_STATE_ONLINING:
5457 5457 ret = STMF_BUSY;
5458 5458 break;
5459 5459 default:
5460 5460 ret = STMF_BADSTATE;
5461 5461 break;
5462 5462 }
5463 5463 if (ret != STMF_SUCCESS)
5464 5464 goto stmf_ctl_lock_exit;
5465 5465
5466 5466 ilport->ilport_state = STMF_STATE_OFFLINING;
5467 5467 mutex_exit(&stmf_state.stmf_lock);
5468 5468 stmf_svc_queue(cmd, obj, (stmf_state_change_info_t *)arg);
5469 5469 break;
5470 5470
5471 5471 case STMF_CMD_LPORT_OFFLINE_COMPLETE:
5472 5472 if (ilport->ilport_state != STMF_STATE_OFFLINING) {
5473 5473 ret = STMF_BADSTATE;
5474 5474 goto stmf_ctl_lock_exit;
5475 5475 }
5476 5476 if (((stmf_change_status_t *)arg)->st_completion_status ==
5477 5477 STMF_SUCCESS) {
5478 5478 ilport->ilport_state = STMF_STATE_OFFLINE;
5479 5479 mutex_exit(&stmf_state.stmf_lock);
5480 5480 ((stmf_local_port_t *)obj)->lport_ctl(
5481 5481 (stmf_local_port_t *)obj,
5482 5482 STMF_ACK_LPORT_OFFLINE_COMPLETE, arg);
5483 5483 mutex_enter(&stmf_state.stmf_lock);
5484 5484 } else {
5485 5485 ilport->ilport_state = STMF_STATE_ONLINE;
5486 5486 }
5487 5487 mutex_exit(&stmf_state.stmf_lock);
5488 5488 break;
5489 5489
5490 5490 default:
5491 5491 cmn_err(CE_WARN, "Invalid ctl cmd received %x", cmd);
5492 5492 ret = STMF_INVALID_ARG;
5493 5493 goto stmf_ctl_lock_exit;
5494 5494 }
5495 5495
5496 5496 return (STMF_SUCCESS);
5497 5497
5498 5498 stmf_ctl_lock_exit:;
5499 5499 mutex_exit(&stmf_state.stmf_lock);
5500 5500 return (ret);
5501 5501 }
5502 5502
5503 5503 /* ARGSUSED */
5504 5504 stmf_status_t
5505 5505 stmf_info_impl(uint32_t cmd, void *arg1, void *arg2, uint8_t *buf,
5506 5506 uint32_t *bufsizep)
5507 5507 {
5508 5508 return (STMF_NOT_SUPPORTED);
5509 5509 }
5510 5510
5511 5511 /* ARGSUSED */
5512 5512 stmf_status_t
5513 5513 stmf_info(uint32_t cmd, void *arg1, void *arg2, uint8_t *buf,
5514 5514 uint32_t *bufsizep)
5515 5515 {
5516 5516 uint32_t cl = SI_GET_CLASS(cmd);
5517 5517
5518 5518 if (cl == SI_STMF) {
5519 5519 return (stmf_info_impl(cmd, arg1, arg2, buf, bufsizep));
5520 5520 }
5521 5521 if (cl == SI_LPORT) {
5522 5522 return (((stmf_local_port_t *)arg1)->lport_info(cmd, arg1,
5523 5523 arg2, buf, bufsizep));
5524 5524 } else if (cl == SI_LU) {
5525 5525 return (((stmf_lu_t *)arg1)->lu_info(cmd, arg1, arg2, buf,
5526 5526 bufsizep));
5527 5527 }
5528 5528
5529 5529 return (STMF_NOT_SUPPORTED);
5530 5530 }
5531 5531
5532 5532 /*
5533 5533 * Used by port providers. pwwn is 8 byte wwn, sdid is the devid used by
5534 5534 * stmf to register local ports. The ident should have 20 bytes in buffer
5535 5535 * space to convert the wwn to "wwn.xxxxxxxxxxxxxxxx" string.
5536 5536 */
5537 5537 void
5538 5538 stmf_wwn_to_devid_desc(scsi_devid_desc_t *sdid, uint8_t *wwn,
5539 5539 uint8_t protocol_id)
5540 5540 {
5541 5541 char wwn_str[20+1];
5542 5542
5543 5543 sdid->protocol_id = protocol_id;
5544 5544 sdid->piv = 1;
5545 5545 sdid->code_set = CODE_SET_ASCII;
5546 5546 sdid->association = ID_IS_TARGET_PORT;
5547 5547 sdid->ident_length = 20;
5548 5548 /* Convert wwn value to "wwn.XXXXXXXXXXXXXXXX" format */
5549 5549 (void) snprintf(wwn_str, sizeof (wwn_str),
5550 5550 "wwn.%02X%02X%02X%02X%02X%02X%02X%02X",
5551 5551 wwn[0], wwn[1], wwn[2], wwn[3], wwn[4], wwn[5], wwn[6], wwn[7]);
5552 5552 bcopy(wwn_str, (char *)sdid->ident, 20);
5553 5553 }
5554 5554
5555 5555
5556 5556 stmf_xfer_data_t *
5557 5557 stmf_prepare_tpgs_data(uint8_t ilu_alua)
5558 5558 {
5559 5559 stmf_xfer_data_t *xd;
5560 5560 stmf_i_local_port_t *ilport;
5561 5561 uint8_t *p;
5562 5562 uint32_t sz, asz, nports = 0, nports_standby = 0;
5563 5563
5564 5564 mutex_enter(&stmf_state.stmf_lock);
5565 5565 /* check if any ports are standby and create second group */
5566 5566 for (ilport = stmf_state.stmf_ilportlist; ilport;
5567 5567 ilport = ilport->ilport_next) {
5568 5568 if (ilport->ilport_standby == 1) {
5569 5569 nports_standby++;
5570 5570 } else {
5571 5571 nports++;
5572 5572 }
5573 5573 }
5574 5574
5575 5575 /* The spec only allows for 255 ports to be reported per group */
5576 5576 nports = min(nports, 255);
5577 5577 nports_standby = min(nports_standby, 255);
5578 5578 sz = (nports * 4) + 12;
5579 5579 if (nports_standby && ilu_alua) {
5580 5580 sz += (nports_standby * 4) + 8;
5581 5581 }
5582 5582 asz = sz + sizeof (*xd) - 4;
5583 5583 xd = (stmf_xfer_data_t *)kmem_zalloc(asz, KM_NOSLEEP);
5584 5584 if (xd == NULL) {
5585 5585 mutex_exit(&stmf_state.stmf_lock);
5586 5586 return (NULL);
5587 5587 }
5588 5588 xd->alloc_size = asz;
5589 5589 xd->size_left = sz;
5590 5590
5591 5591 p = xd->buf;
5592 5592
5593 5593 *((uint32_t *)p) = BE_32(sz - 4);
5594 5594 p += 4;
5595 5595 p[0] = 0x80; /* PREF */
5596 5596 p[1] = 5; /* AO_SUP, S_SUP */
5597 5597 if (stmf_state.stmf_alua_node == 1) {
5598 5598 p[3] = 1; /* Group 1 */
5599 5599 } else {
5600 5600 p[3] = 0; /* Group 0 */
5601 5601 }
5602 5602 p[7] = nports & 0xff;
5603 5603 p += 8;
5604 5604 for (ilport = stmf_state.stmf_ilportlist; ilport;
5605 5605 ilport = ilport->ilport_next) {
5606 5606 if (ilport->ilport_standby == 1) {
5607 5607 continue;
5608 5608 }
5609 5609 ((uint16_t *)p)[1] = BE_16(ilport->ilport_rtpid);
5610 5610 p += 4;
5611 5611 }
5612 5612 if (nports_standby && ilu_alua) {
5613 5613 p[0] = 0x02; /* Non PREF, Standby */
5614 5614 p[1] = 5; /* AO_SUP, S_SUP */
5615 5615 if (stmf_state.stmf_alua_node == 1) {
5616 5616 p[3] = 0; /* Group 0 */
5617 5617 } else {
5618 5618 p[3] = 1; /* Group 1 */
5619 5619 }
5620 5620 p[7] = nports_standby & 0xff;
5621 5621 p += 8;
5622 5622 for (ilport = stmf_state.stmf_ilportlist; ilport;
5623 5623 ilport = ilport->ilport_next) {
5624 5624 if (ilport->ilport_standby == 0) {
5625 5625 continue;
5626 5626 }
5627 5627 ((uint16_t *)p)[1] = BE_16(ilport->ilport_rtpid);
5628 5628 p += 4;
5629 5629 }
5630 5630 }
5631 5631
5632 5632 mutex_exit(&stmf_state.stmf_lock);
5633 5633
5634 5634 return (xd);
5635 5635 }
5636 5636
5637 5637 struct scsi_devid_desc *
5638 5638 stmf_scsilib_get_devid_desc(uint16_t rtpid)
5639 5639 {
5640 5640 scsi_devid_desc_t *devid = NULL;
5641 5641 stmf_i_local_port_t *ilport;
5642 5642
5643 5643 mutex_enter(&stmf_state.stmf_lock);
5644 5644
5645 5645 for (ilport = stmf_state.stmf_ilportlist; ilport;
5646 5646 ilport = ilport->ilport_next) {
5647 5647 if (ilport->ilport_rtpid == rtpid) {
5648 5648 scsi_devid_desc_t *id = ilport->ilport_lport->lport_id;
5649 5649 uint32_t id_sz = sizeof (scsi_devid_desc_t) +
5650 5650 id->ident_length;
5651 5651 devid = (scsi_devid_desc_t *)kmem_zalloc(id_sz,
5652 5652 KM_NOSLEEP);
5653 5653 if (devid != NULL) {
5654 5654 bcopy(id, devid, id_sz);
5655 5655 }
5656 5656 break;
5657 5657 }
5658 5658 }
5659 5659
5660 5660 mutex_exit(&stmf_state.stmf_lock);
5661 5661 return (devid);
5662 5662 }
5663 5663
5664 5664 uint16_t
5665 5665 stmf_scsilib_get_lport_rtid(struct scsi_devid_desc *devid)
5666 5666 {
5667 5667 stmf_i_local_port_t *ilport;
5668 5668 scsi_devid_desc_t *id;
5669 5669 uint16_t rtpid = 0;
5670 5670
5671 5671 mutex_enter(&stmf_state.stmf_lock);
5672 5672 for (ilport = stmf_state.stmf_ilportlist; ilport;
5673 5673 ilport = ilport->ilport_next) {
5674 5674 id = ilport->ilport_lport->lport_id;
5675 5675 if ((devid->ident_length == id->ident_length) &&
5676 5676 (memcmp(devid->ident, id->ident, id->ident_length) == 0)) {
5677 5677 rtpid = ilport->ilport_rtpid;
5678 5678 break;
5679 5679 }
5680 5680 }
5681 5681 mutex_exit(&stmf_state.stmf_lock);
5682 5682 return (rtpid);
5683 5683 }
5684 5684
5685 5685 static uint16_t stmf_lu_id_gen_number = 0;
5686 5686
5687 5687 stmf_status_t
5688 5688 stmf_scsilib_uniq_lu_id(uint32_t company_id, scsi_devid_desc_t *lu_id)
5689 5689 {
5690 5690 return (stmf_scsilib_uniq_lu_id2(company_id, 0, lu_id));
5691 5691 }
5692 5692
5693 5693 stmf_status_t
5694 5694 stmf_scsilib_uniq_lu_id2(uint32_t company_id, uint32_t host_id,
5695 5695 scsi_devid_desc_t *lu_id)
5696 5696 {
5697 5697 uint8_t *p;
5698 5698 struct timeval32 timestamp32;
5699 5699 uint32_t *t = (uint32_t *)×tamp32;
5700 5700 struct ether_addr mac;
5701 5701 uint8_t *e = (uint8_t *)&mac;
5702 5702 int hid = (int)host_id;
|
↓ open down ↓ |
1076 lines elided |
↑ open up ↑ |
5703 5703 uint16_t gen_number;
5704 5704
5705 5705 if (company_id == COMPANY_ID_NONE)
5706 5706 company_id = COMPANY_ID_SUN;
5707 5707
5708 5708 if (lu_id->ident_length != 0x10)
5709 5709 return (STMF_INVALID_ARG);
5710 5710
5711 5711 p = (uint8_t *)lu_id;
5712 5712
5713 - gen_number = atomic_add_16_nv(&stmf_lu_id_gen_number, 1);
5713 + gen_number = atomic_inc_16_nv(&stmf_lu_id_gen_number);
5714 5714
5715 5715 p[0] = 0xf1; p[1] = 3; p[2] = 0; p[3] = 0x10;
5716 5716 p[4] = ((company_id >> 20) & 0xf) | 0x60;
5717 5717 p[5] = (company_id >> 12) & 0xff;
5718 5718 p[6] = (company_id >> 4) & 0xff;
5719 5719 p[7] = (company_id << 4) & 0xf0;
5720 5720 if (hid == 0 && !localetheraddr((struct ether_addr *)NULL, &mac)) {
5721 5721 hid = BE_32((int)zone_get_hostid(NULL));
5722 5722 }
5723 5723 if (hid != 0) {
5724 5724 e[0] = (hid >> 24) & 0xff;
5725 5725 e[1] = (hid >> 16) & 0xff;
5726 5726 e[2] = (hid >> 8) & 0xff;
5727 5727 e[3] = hid & 0xff;
5728 5728 e[4] = e[5] = 0;
5729 5729 }
5730 5730 bcopy(e, p+8, 6);
5731 5731 uniqtime32(×tamp32);
5732 5732 *t = BE_32(*t);
5733 5733 bcopy(t, p+14, 4);
5734 5734 p[18] = (gen_number >> 8) & 0xff;
5735 5735 p[19] = gen_number & 0xff;
5736 5736
5737 5737 return (STMF_SUCCESS);
5738 5738 }
5739 5739
5740 5740 /*
5741 5741 * saa is sense key, ASC, ASCQ
5742 5742 */
5743 5743 void
5744 5744 stmf_scsilib_send_status(scsi_task_t *task, uint8_t st, uint32_t saa)
5745 5745 {
5746 5746 uint8_t sd[18];
5747 5747 task->task_scsi_status = st;
5748 5748 if (st == 2) {
5749 5749 bzero(sd, 18);
5750 5750 sd[0] = 0x70;
5751 5751 sd[2] = (saa >> 16) & 0xf;
5752 5752 sd[7] = 10;
5753 5753 sd[12] = (saa >> 8) & 0xff;
5754 5754 sd[13] = saa & 0xff;
5755 5755 task->task_sense_data = sd;
5756 5756 task->task_sense_length = 18;
5757 5757 } else {
5758 5758 task->task_sense_data = NULL;
5759 5759 task->task_sense_length = 0;
5760 5760 }
5761 5761 (void) stmf_send_scsi_status(task, STMF_IOF_LU_DONE);
5762 5762 }
5763 5763
5764 5764 uint32_t
5765 5765 stmf_scsilib_prepare_vpd_page83(scsi_task_t *task, uint8_t *page,
5766 5766 uint32_t page_len, uint8_t byte0, uint32_t vpd_mask)
5767 5767 {
5768 5768 uint8_t *p = NULL;
5769 5769 uint8_t small_buf[32];
5770 5770 uint32_t sz = 0;
5771 5771 uint32_t n = 4;
5772 5772 uint32_t m = 0;
5773 5773 uint32_t last_bit = 0;
5774 5774
5775 5775 if (page_len < 4)
5776 5776 return (0);
5777 5777 if (page_len > 65535)
5778 5778 page_len = 65535;
5779 5779
5780 5780 page[0] = byte0;
5781 5781 page[1] = 0x83;
5782 5782
5783 5783 /* CONSTCOND */
5784 5784 while (1) {
5785 5785 m += sz;
5786 5786 if (sz && (page_len > n)) {
5787 5787 uint32_t copysz;
5788 5788 copysz = page_len > (n + sz) ? sz : page_len - n;
5789 5789 bcopy(p, page + n, copysz);
5790 5790 n += copysz;
5791 5791 }
5792 5792 vpd_mask &= ~last_bit;
5793 5793 if (vpd_mask == 0)
5794 5794 break;
5795 5795
5796 5796 if (vpd_mask & STMF_VPD_LU_ID) {
5797 5797 last_bit = STMF_VPD_LU_ID;
5798 5798 sz = task->task_lu->lu_id->ident_length + 4;
5799 5799 p = (uint8_t *)task->task_lu->lu_id;
5800 5800 continue;
5801 5801 } else if (vpd_mask & STMF_VPD_TARGET_ID) {
5802 5802 last_bit = STMF_VPD_TARGET_ID;
5803 5803 sz = task->task_lport->lport_id->ident_length + 4;
5804 5804 p = (uint8_t *)task->task_lport->lport_id;
5805 5805 continue;
5806 5806 } else if (vpd_mask & STMF_VPD_TP_GROUP) {
5807 5807 stmf_i_local_port_t *ilport;
5808 5808 last_bit = STMF_VPD_TP_GROUP;
5809 5809 p = small_buf;
5810 5810 bzero(p, 8);
5811 5811 p[0] = 1;
5812 5812 p[1] = 0x15;
5813 5813 p[3] = 4;
5814 5814 ilport = (stmf_i_local_port_t *)
5815 5815 task->task_lport->lport_stmf_private;
5816 5816 /*
5817 5817 * If we're in alua mode, group 1 contains all alua
5818 5818 * participating ports and all standby ports
5819 5819 * > 255. Otherwise, if we're in alua mode, any local
5820 5820 * ports (non standby/pppt) are also in group 1 if the
5821 5821 * alua node is 1. Otherwise the group is 0.
5822 5822 */
5823 5823 if ((stmf_state.stmf_alua_state &&
5824 5824 (ilport->ilport_alua || ilport->ilport_standby) &&
5825 5825 ilport->ilport_rtpid > 255) ||
5826 5826 (stmf_state.stmf_alua_node == 1 &&
5827 5827 ilport->ilport_standby != 1)) {
5828 5828 p[7] = 1; /* Group 1 */
5829 5829 }
5830 5830 sz = 8;
5831 5831 continue;
5832 5832 } else if (vpd_mask & STMF_VPD_RELATIVE_TP_ID) {
5833 5833 stmf_i_local_port_t *ilport;
5834 5834
5835 5835 last_bit = STMF_VPD_RELATIVE_TP_ID;
5836 5836 p = small_buf;
5837 5837 bzero(p, 8);
5838 5838 p[0] = 1;
5839 5839 p[1] = 0x14;
5840 5840 p[3] = 4;
5841 5841 ilport = (stmf_i_local_port_t *)
5842 5842 task->task_lport->lport_stmf_private;
5843 5843 p[6] = (ilport->ilport_rtpid >> 8) & 0xff;
5844 5844 p[7] = ilport->ilport_rtpid & 0xff;
5845 5845 sz = 8;
5846 5846 continue;
5847 5847 } else {
5848 5848 cmn_err(CE_WARN, "Invalid vpd_mask");
5849 5849 break;
5850 5850 }
5851 5851 }
5852 5852
5853 5853 page[2] = (m >> 8) & 0xff;
5854 5854 page[3] = m & 0xff;
5855 5855
5856 5856 return (n);
5857 5857 }
5858 5858
5859 5859 void
5860 5860 stmf_scsilib_handle_report_tpgs(scsi_task_t *task, stmf_data_buf_t *dbuf)
5861 5861 {
5862 5862 stmf_i_scsi_task_t *itask =
5863 5863 (stmf_i_scsi_task_t *)task->task_stmf_private;
5864 5864 stmf_i_lu_t *ilu =
5865 5865 (stmf_i_lu_t *)task->task_lu->lu_stmf_private;
5866 5866 stmf_xfer_data_t *xd;
5867 5867 uint32_t sz, minsz;
5868 5868
5869 5869 itask->itask_flags |= ITASK_DEFAULT_HANDLING;
5870 5870 task->task_cmd_xfer_length =
5871 5871 ((((uint32_t)task->task_cdb[6]) << 24) |
5872 5872 (((uint32_t)task->task_cdb[7]) << 16) |
5873 5873 (((uint32_t)task->task_cdb[8]) << 8) |
5874 5874 ((uint32_t)task->task_cdb[9]));
5875 5875
5876 5876 if (task->task_additional_flags &
5877 5877 TASK_AF_NO_EXPECTED_XFER_LENGTH) {
5878 5878 task->task_expected_xfer_length =
5879 5879 task->task_cmd_xfer_length;
5880 5880 }
5881 5881
5882 5882 if (task->task_cmd_xfer_length == 0) {
5883 5883 stmf_scsilib_send_status(task, STATUS_GOOD, 0);
5884 5884 return;
5885 5885 }
5886 5886 if (task->task_cmd_xfer_length < 4) {
5887 5887 stmf_scsilib_send_status(task, STATUS_CHECK,
5888 5888 STMF_SAA_INVALID_FIELD_IN_CDB);
5889 5889 return;
5890 5890 }
5891 5891
5892 5892 sz = min(task->task_expected_xfer_length,
5893 5893 task->task_cmd_xfer_length);
5894 5894
5895 5895 xd = stmf_prepare_tpgs_data(ilu->ilu_alua);
5896 5896
5897 5897 if (xd == NULL) {
5898 5898 stmf_abort(STMF_QUEUE_TASK_ABORT, task,
5899 5899 STMF_ALLOC_FAILURE, NULL);
5900 5900 return;
5901 5901 }
5902 5902
5903 5903 sz = min(sz, xd->size_left);
5904 5904 xd->size_left = sz;
5905 5905 minsz = min(512, sz);
5906 5906
5907 5907 if (dbuf == NULL)
5908 5908 dbuf = stmf_alloc_dbuf(task, sz, &minsz, 0);
5909 5909 if (dbuf == NULL) {
5910 5910 kmem_free(xd, xd->alloc_size);
5911 5911 stmf_abort(STMF_QUEUE_TASK_ABORT, task,
5912 5912 STMF_ALLOC_FAILURE, NULL);
5913 5913 return;
5914 5914 }
5915 5915 dbuf->db_lu_private = xd;
5916 5916 stmf_xd_to_dbuf(dbuf, 1);
5917 5917
5918 5918 dbuf->db_flags = DB_DIRECTION_TO_RPORT;
5919 5919 (void) stmf_xfer_data(task, dbuf, 0);
5920 5920
5921 5921 }
5922 5922
5923 5923 void
5924 5924 stmf_scsilib_handle_task_mgmt(scsi_task_t *task)
5925 5925 {
5926 5926
5927 5927 switch (task->task_mgmt_function) {
5928 5928 /*
5929 5929 * For now we will abort all I/Os on the LU in case of ABORT_TASK_SET
5930 5930 * and ABORT_TASK. But unlike LUN_RESET we will not reset LU state
5931 5931 * in these cases. This needs to be changed to abort only the required
5932 5932 * set.
5933 5933 */
5934 5934 case TM_ABORT_TASK:
5935 5935 case TM_ABORT_TASK_SET:
5936 5936 case TM_CLEAR_TASK_SET:
5937 5937 case TM_LUN_RESET:
5938 5938 stmf_handle_lun_reset(task);
5939 5939 /* issue the reset to the proxy node as well */
5940 5940 if (stmf_state.stmf_alua_state == 1) {
5941 5941 (void) stmf_proxy_scsi_cmd(task, NULL);
5942 5942 }
5943 5943 return;
5944 5944 case TM_TARGET_RESET:
5945 5945 case TM_TARGET_COLD_RESET:
5946 5946 case TM_TARGET_WARM_RESET:
5947 5947 stmf_handle_target_reset(task);
5948 5948 return;
5949 5949 default:
5950 5950 /* We dont support this task mgmt function */
5951 5951 stmf_scsilib_send_status(task, STATUS_CHECK,
5952 5952 STMF_SAA_INVALID_FIELD_IN_CMD_IU);
5953 5953 return;
5954 5954 }
5955 5955 }
5956 5956
5957 5957 void
5958 5958 stmf_handle_lun_reset(scsi_task_t *task)
5959 5959 {
5960 5960 stmf_i_scsi_task_t *itask;
5961 5961 stmf_i_lu_t *ilu;
5962 5962
5963 5963 itask = (stmf_i_scsi_task_t *)task->task_stmf_private;
5964 5964 ilu = (stmf_i_lu_t *)task->task_lu->lu_stmf_private;
5965 5965
5966 5966 /*
5967 5967 * To sync with target reset, grab this lock. The LU is not going
5968 5968 * anywhere as there is atleast one task pending (this task).
5969 5969 */
5970 5970 mutex_enter(&stmf_state.stmf_lock);
5971 5971
5972 5972 if (ilu->ilu_flags & ILU_RESET_ACTIVE) {
5973 5973 mutex_exit(&stmf_state.stmf_lock);
5974 5974 stmf_scsilib_send_status(task, STATUS_CHECK,
5975 5975 STMF_SAA_OPERATION_IN_PROGRESS);
5976 5976 return;
5977 5977 }
5978 5978 atomic_or_32(&ilu->ilu_flags, ILU_RESET_ACTIVE);
5979 5979 mutex_exit(&stmf_state.stmf_lock);
5980 5980
5981 5981 /*
5982 5982 * Mark this task as the one causing LU reset so that we know who
5983 5983 * was responsible for setting the ILU_RESET_ACTIVE. In case this
5984 5984 * task itself gets aborted, we will clear ILU_RESET_ACTIVE.
5985 5985 */
5986 5986 itask->itask_flags |= ITASK_DEFAULT_HANDLING | ITASK_CAUSING_LU_RESET;
5987 5987
5988 5988 /* Initiatiate abort on all commands on this LU except this one */
5989 5989 stmf_abort(STMF_QUEUE_ABORT_LU, task, STMF_ABORTED, task->task_lu);
5990 5990
5991 5991 /* Start polling on this task */
5992 5992 if (stmf_task_poll_lu(task, ITASK_DEFAULT_POLL_TIMEOUT)
5993 5993 != STMF_SUCCESS) {
5994 5994 stmf_abort(STMF_QUEUE_TASK_ABORT, task, STMF_ALLOC_FAILURE,
5995 5995 NULL);
5996 5996 return;
5997 5997 }
5998 5998 }
5999 5999
6000 6000 void
6001 6001 stmf_handle_target_reset(scsi_task_t *task)
6002 6002 {
6003 6003 stmf_i_scsi_task_t *itask;
6004 6004 stmf_i_lu_t *ilu;
6005 6005 stmf_i_scsi_session_t *iss;
6006 6006 stmf_lun_map_t *lm;
6007 6007 stmf_lun_map_ent_t *lm_ent;
6008 6008 int i, lf;
6009 6009
6010 6010 itask = (stmf_i_scsi_task_t *)task->task_stmf_private;
6011 6011 iss = (stmf_i_scsi_session_t *)task->task_session->ss_stmf_private;
6012 6012 ilu = (stmf_i_lu_t *)task->task_lu->lu_stmf_private;
6013 6013
6014 6014 /*
6015 6015 * To sync with LUN reset, grab this lock. The session is not going
6016 6016 * anywhere as there is atleast one task pending (this task).
6017 6017 */
6018 6018 mutex_enter(&stmf_state.stmf_lock);
6019 6019
6020 6020 /* Grab the session lock as a writer to prevent any changes in it */
6021 6021 rw_enter(iss->iss_lockp, RW_WRITER);
6022 6022
6023 6023 if (iss->iss_flags & ISS_RESET_ACTIVE) {
6024 6024 rw_exit(iss->iss_lockp);
6025 6025 mutex_exit(&stmf_state.stmf_lock);
6026 6026 stmf_scsilib_send_status(task, STATUS_CHECK,
6027 6027 STMF_SAA_OPERATION_IN_PROGRESS);
6028 6028 return;
6029 6029 }
6030 6030 atomic_or_32(&iss->iss_flags, ISS_RESET_ACTIVE);
6031 6031
6032 6032 /*
6033 6033 * Now go through each LUN in this session and make sure all of them
6034 6034 * can be reset.
6035 6035 */
6036 6036 lm = iss->iss_sm;
6037 6037 for (i = 0, lf = 0; i < lm->lm_nentries; i++) {
6038 6038 if (lm->lm_plus[i] == NULL)
6039 6039 continue;
6040 6040 lf++;
6041 6041 lm_ent = (stmf_lun_map_ent_t *)lm->lm_plus[i];
6042 6042 ilu = (stmf_i_lu_t *)(lm_ent->ent_lu->lu_stmf_private);
6043 6043 if (ilu->ilu_flags & ILU_RESET_ACTIVE) {
6044 6044 atomic_and_32(&iss->iss_flags, ~ISS_RESET_ACTIVE);
6045 6045 rw_exit(iss->iss_lockp);
6046 6046 mutex_exit(&stmf_state.stmf_lock);
6047 6047 stmf_scsilib_send_status(task, STATUS_CHECK,
6048 6048 STMF_SAA_OPERATION_IN_PROGRESS);
6049 6049 return;
6050 6050 }
6051 6051 }
6052 6052 if (lf == 0) {
6053 6053 /* No luns in this session */
6054 6054 atomic_and_32(&iss->iss_flags, ~ISS_RESET_ACTIVE);
6055 6055 rw_exit(iss->iss_lockp);
6056 6056 mutex_exit(&stmf_state.stmf_lock);
6057 6057 stmf_scsilib_send_status(task, STATUS_GOOD, 0);
6058 6058 return;
6059 6059 }
6060 6060
6061 6061 /* ok, start the damage */
6062 6062 itask->itask_flags |= ITASK_DEFAULT_HANDLING |
6063 6063 ITASK_CAUSING_TARGET_RESET;
6064 6064 for (i = 0; i < lm->lm_nentries; i++) {
6065 6065 if (lm->lm_plus[i] == NULL)
6066 6066 continue;
6067 6067 lm_ent = (stmf_lun_map_ent_t *)lm->lm_plus[i];
6068 6068 ilu = (stmf_i_lu_t *)(lm_ent->ent_lu->lu_stmf_private);
6069 6069 atomic_or_32(&ilu->ilu_flags, ILU_RESET_ACTIVE);
6070 6070 }
6071 6071
6072 6072 for (i = 0; i < lm->lm_nentries; i++) {
6073 6073 if (lm->lm_plus[i] == NULL)
6074 6074 continue;
6075 6075 lm_ent = (stmf_lun_map_ent_t *)lm->lm_plus[i];
6076 6076 stmf_abort(STMF_QUEUE_ABORT_LU, task, STMF_ABORTED,
6077 6077 lm_ent->ent_lu);
6078 6078 }
6079 6079
6080 6080 rw_exit(iss->iss_lockp);
6081 6081 mutex_exit(&stmf_state.stmf_lock);
6082 6082
6083 6083 /* Start polling on this task */
6084 6084 if (stmf_task_poll_lu(task, ITASK_DEFAULT_POLL_TIMEOUT)
6085 6085 != STMF_SUCCESS) {
6086 6086 stmf_abort(STMF_QUEUE_TASK_ABORT, task, STMF_ALLOC_FAILURE,
6087 6087 NULL);
6088 6088 return;
6089 6089 }
6090 6090 }
6091 6091
6092 6092 int
6093 6093 stmf_handle_cmd_during_ic(stmf_i_scsi_task_t *itask)
6094 6094 {
6095 6095 scsi_task_t *task = itask->itask_task;
6096 6096 stmf_i_scsi_session_t *iss = (stmf_i_scsi_session_t *)
6097 6097 task->task_session->ss_stmf_private;
6098 6098
6099 6099 rw_enter(iss->iss_lockp, RW_WRITER);
6100 6100 if (((iss->iss_flags & ISS_LUN_INVENTORY_CHANGED) == 0) ||
6101 6101 (task->task_cdb[0] == SCMD_INQUIRY)) {
6102 6102 rw_exit(iss->iss_lockp);
6103 6103 return (0);
6104 6104 }
6105 6105 atomic_and_32(&iss->iss_flags,
6106 6106 ~(ISS_LUN_INVENTORY_CHANGED | ISS_GOT_INITIAL_LUNS));
6107 6107 rw_exit(iss->iss_lockp);
6108 6108
6109 6109 if (task->task_cdb[0] == SCMD_REPORT_LUNS) {
6110 6110 return (0);
6111 6111 }
6112 6112 stmf_scsilib_send_status(task, STATUS_CHECK,
6113 6113 STMF_SAA_REPORT_LUN_DATA_HAS_CHANGED);
6114 6114 return (1);
6115 6115 }
6116 6116
6117 6117 void
6118 6118 stmf_worker_init()
6119 6119 {
6120 6120 uint32_t i;
6121 6121
6122 6122 /* Make local copy of global tunables */
6123 6123 stmf_i_max_nworkers = stmf_max_nworkers;
6124 6124 stmf_i_min_nworkers = stmf_min_nworkers;
6125 6125
6126 6126 ASSERT(stmf_workers == NULL);
6127 6127 if (stmf_i_min_nworkers < 4) {
6128 6128 stmf_i_min_nworkers = 4;
6129 6129 }
6130 6130 if (stmf_i_max_nworkers < stmf_i_min_nworkers) {
6131 6131 stmf_i_max_nworkers = stmf_i_min_nworkers;
6132 6132 }
6133 6133 stmf_workers = (stmf_worker_t *)kmem_zalloc(
6134 6134 sizeof (stmf_worker_t) * stmf_i_max_nworkers, KM_SLEEP);
6135 6135 for (i = 0; i < stmf_i_max_nworkers; i++) {
6136 6136 stmf_worker_t *w = &stmf_workers[i];
6137 6137 mutex_init(&w->worker_lock, NULL, MUTEX_DRIVER, NULL);
6138 6138 cv_init(&w->worker_cv, NULL, CV_DRIVER, NULL);
6139 6139 }
6140 6140 stmf_worker_mgmt_delay = drv_usectohz(20 * 1000);
6141 6141 stmf_workers_state = STMF_WORKERS_ENABLED;
6142 6142
6143 6143 /* Workers will be started by stmf_worker_mgmt() */
6144 6144
6145 6145 /* Lets wait for atleast one worker to start */
6146 6146 while (stmf_nworkers_cur == 0)
6147 6147 delay(drv_usectohz(20 * 1000));
6148 6148 stmf_worker_mgmt_delay = drv_usectohz(3 * 1000 * 1000);
6149 6149 }
6150 6150
6151 6151 stmf_status_t
6152 6152 stmf_worker_fini()
6153 6153 {
6154 6154 int i;
6155 6155 clock_t sb;
6156 6156
6157 6157 if (stmf_workers_state == STMF_WORKERS_DISABLED)
6158 6158 return (STMF_SUCCESS);
6159 6159 ASSERT(stmf_workers);
6160 6160 stmf_workers_state = STMF_WORKERS_DISABLED;
6161 6161 stmf_worker_mgmt_delay = drv_usectohz(20 * 1000);
6162 6162 cv_signal(&stmf_state.stmf_cv);
6163 6163
6164 6164 sb = ddi_get_lbolt() + drv_usectohz(10 * 1000 * 1000);
6165 6165 /* Wait for all the threads to die */
6166 6166 while (stmf_nworkers_cur != 0) {
6167 6167 if (ddi_get_lbolt() > sb) {
6168 6168 stmf_workers_state = STMF_WORKERS_ENABLED;
6169 6169 return (STMF_BUSY);
6170 6170 }
6171 6171 delay(drv_usectohz(100 * 1000));
6172 6172 }
6173 6173 for (i = 0; i < stmf_i_max_nworkers; i++) {
6174 6174 stmf_worker_t *w = &stmf_workers[i];
6175 6175 mutex_destroy(&w->worker_lock);
6176 6176 cv_destroy(&w->worker_cv);
6177 6177 }
6178 6178 kmem_free(stmf_workers, sizeof (stmf_worker_t) * stmf_i_max_nworkers);
6179 6179 stmf_workers = NULL;
6180 6180
6181 6181 return (STMF_SUCCESS);
6182 6182 }
6183 6183
6184 6184 void
6185 6185 stmf_worker_task(void *arg)
6186 6186 {
6187 6187 stmf_worker_t *w;
6188 6188 stmf_i_scsi_session_t *iss;
6189 6189 scsi_task_t *task;
6190 6190 stmf_i_scsi_task_t *itask;
6191 6191 stmf_data_buf_t *dbuf;
6192 6192 stmf_lu_t *lu;
6193 6193 clock_t wait_timer = 0;
6194 6194 clock_t wait_ticks, wait_delta = 0;
6195 6195 uint32_t old, new;
6196 6196 uint8_t curcmd;
6197 6197 uint8_t abort_free;
6198 6198 uint8_t wait_queue;
6199 6199 uint8_t dec_qdepth;
6200 6200
6201 6201 w = (stmf_worker_t *)arg;
6202 6202 wait_ticks = drv_usectohz(10000);
6203 6203
6204 6204 DTRACE_PROBE1(worker__create, stmf_worker_t, w);
6205 6205 mutex_enter(&w->worker_lock);
6206 6206 w->worker_flags |= STMF_WORKER_STARTED | STMF_WORKER_ACTIVE;
6207 6207 stmf_worker_loop:;
6208 6208 if ((w->worker_ref_count == 0) &&
6209 6209 (w->worker_flags & STMF_WORKER_TERMINATE)) {
6210 6210 w->worker_flags &= ~(STMF_WORKER_STARTED |
6211 6211 STMF_WORKER_ACTIVE | STMF_WORKER_TERMINATE);
6212 6212 w->worker_tid = NULL;
6213 6213 mutex_exit(&w->worker_lock);
6214 6214 DTRACE_PROBE1(worker__destroy, stmf_worker_t, w);
6215 6215 thread_exit();
6216 6216 }
6217 6217 /* CONSTCOND */
6218 6218 while (1) {
6219 6219 dec_qdepth = 0;
6220 6220 if (wait_timer && (ddi_get_lbolt() >= wait_timer)) {
6221 6221 wait_timer = 0;
6222 6222 wait_delta = 0;
6223 6223 if (w->worker_wait_head) {
6224 6224 ASSERT(w->worker_wait_tail);
6225 6225 if (w->worker_task_head == NULL)
6226 6226 w->worker_task_head =
6227 6227 w->worker_wait_head;
6228 6228 else
6229 6229 w->worker_task_tail->itask_worker_next =
6230 6230 w->worker_wait_head;
6231 6231 w->worker_task_tail = w->worker_wait_tail;
6232 6232 w->worker_wait_head = w->worker_wait_tail =
6233 6233 NULL;
6234 6234 }
6235 6235 }
6236 6236 if ((itask = w->worker_task_head) == NULL) {
6237 6237 break;
6238 6238 }
6239 6239 task = itask->itask_task;
6240 6240 DTRACE_PROBE2(worker__active, stmf_worker_t, w,
6241 6241 scsi_task_t *, task);
6242 6242 w->worker_task_head = itask->itask_worker_next;
6243 6243 if (w->worker_task_head == NULL)
6244 6244 w->worker_task_tail = NULL;
6245 6245
6246 6246 wait_queue = 0;
6247 6247 abort_free = 0;
6248 6248 if (itask->itask_ncmds > 0) {
6249 6249 curcmd = itask->itask_cmd_stack[itask->itask_ncmds - 1];
6250 6250 } else {
6251 6251 ASSERT(itask->itask_flags & ITASK_BEING_ABORTED);
6252 6252 }
6253 6253 do {
6254 6254 old = itask->itask_flags;
6255 6255 if (old & ITASK_BEING_ABORTED) {
6256 6256 itask->itask_ncmds = 1;
6257 6257 curcmd = itask->itask_cmd_stack[0] =
6258 6258 ITASK_CMD_ABORT;
6259 6259 goto out_itask_flag_loop;
6260 6260 } else if ((curcmd & ITASK_CMD_MASK) ==
6261 6261 ITASK_CMD_NEW_TASK) {
6262 6262 /*
6263 6263 * set ITASK_KSTAT_IN_RUNQ, this flag
6264 6264 * will not reset until task completed
6265 6265 */
6266 6266 new = old | ITASK_KNOWN_TO_LU |
6267 6267 ITASK_KSTAT_IN_RUNQ;
6268 6268 } else {
6269 6269 goto out_itask_flag_loop;
6270 6270 }
6271 6271 } while (atomic_cas_32(&itask->itask_flags, old, new) != old);
6272 6272
6273 6273 out_itask_flag_loop:
6274 6274
6275 6275 /*
6276 6276 * Decide if this task needs to go to a queue and/or if
6277 6277 * we can decrement the itask_cmd_stack.
6278 6278 */
6279 6279 if (curcmd == ITASK_CMD_ABORT) {
6280 6280 if (itask->itask_flags & (ITASK_KNOWN_TO_LU |
6281 6281 ITASK_KNOWN_TO_TGT_PORT)) {
6282 6282 wait_queue = 1;
6283 6283 } else {
6284 6284 abort_free = 1;
6285 6285 }
6286 6286 } else if ((curcmd & ITASK_CMD_POLL) &&
6287 6287 (itask->itask_poll_timeout > ddi_get_lbolt())) {
6288 6288 wait_queue = 1;
6289 6289 }
6290 6290
6291 6291 if (wait_queue) {
6292 6292 itask->itask_worker_next = NULL;
6293 6293 if (w->worker_wait_tail) {
6294 6294 w->worker_wait_tail->itask_worker_next = itask;
6295 6295 } else {
6296 6296 w->worker_wait_head = itask;
6297 6297 }
6298 6298 w->worker_wait_tail = itask;
6299 6299 if (wait_timer == 0) {
6300 6300 wait_timer = ddi_get_lbolt() + wait_ticks;
6301 6301 wait_delta = wait_ticks;
6302 6302 }
6303 6303 } else if ((--(itask->itask_ncmds)) != 0) {
6304 6304 itask->itask_worker_next = NULL;
6305 6305 if (w->worker_task_tail) {
6306 6306 w->worker_task_tail->itask_worker_next = itask;
6307 6307 } else {
6308 6308 w->worker_task_head = itask;
6309 6309 }
6310 6310 w->worker_task_tail = itask;
6311 6311 } else {
6312 6312 atomic_and_32(&itask->itask_flags,
6313 6313 ~ITASK_IN_WORKER_QUEUE);
6314 6314 /*
6315 6315 * This is where the queue depth should go down by
6316 6316 * one but we delay that on purpose to account for
6317 6317 * the call into the provider. The actual decrement
6318 6318 * happens after the worker has done its job.
6319 6319 */
6320 6320 dec_qdepth = 1;
6321 6321 itask->itask_waitq_time +=
6322 6322 gethrtime() - itask->itask_waitq_enter_timestamp;
6323 6323 }
6324 6324
6325 6325 /* We made it here means we are going to call LU */
6326 6326 if ((itask->itask_flags & ITASK_DEFAULT_HANDLING) == 0)
6327 6327 lu = task->task_lu;
6328 6328 else
6329 6329 lu = dlun0;
6330 6330 dbuf = itask->itask_dbufs[ITASK_CMD_BUF_NDX(curcmd)];
6331 6331 mutex_exit(&w->worker_lock);
6332 6332 curcmd &= ITASK_CMD_MASK;
6333 6333 stmf_task_audit(itask, TE_PROCESS_CMD, curcmd, dbuf);
6334 6334 switch (curcmd) {
|
↓ open down ↓ |
611 lines elided |
↑ open up ↑ |
6335 6335 case ITASK_CMD_NEW_TASK:
6336 6336 iss = (stmf_i_scsi_session_t *)
6337 6337 task->task_session->ss_stmf_private;
6338 6338 stmf_itl_lu_new_task(itask);
6339 6339 if (iss->iss_flags & ISS_LUN_INVENTORY_CHANGED) {
6340 6340 if (stmf_handle_cmd_during_ic(itask))
6341 6341 break;
6342 6342 }
6343 6343 #ifdef DEBUG
6344 6344 if (stmf_drop_task_counter > 0) {
6345 - if (atomic_add_32_nv(
6346 - (uint32_t *)&stmf_drop_task_counter,
6347 - -1) == 1) {
6345 + if (atomic_dec_32_nv((uint32_t *)&stmf_drop_task_counter) ==
6346 + 1) {
6348 6347 break;
6349 6348 }
6350 6349 }
6351 6350 #endif
6352 6351 DTRACE_PROBE1(scsi__task__start, scsi_task_t *, task);
6353 6352 lu->lu_new_task(task, dbuf);
6354 6353 break;
6355 6354 case ITASK_CMD_DATA_XFER_DONE:
6356 6355 lu->lu_dbuf_xfer_done(task, dbuf);
6357 6356 break;
6358 6357 case ITASK_CMD_STATUS_DONE:
6359 6358 lu->lu_send_status_done(task);
6360 6359 break;
6361 6360 case ITASK_CMD_ABORT:
6362 6361 if (abort_free) {
6363 6362 stmf_task_free(task);
6364 6363 } else {
6365 6364 stmf_do_task_abort(task);
6366 6365 }
6367 6366 break;
6368 6367 case ITASK_CMD_POLL_LU:
6369 6368 if (!wait_queue) {
6370 6369 lu->lu_task_poll(task);
6371 6370 }
6372 6371 break;
6373 6372 case ITASK_CMD_POLL_LPORT:
6374 6373 if (!wait_queue)
6375 6374 task->task_lport->lport_task_poll(task);
6376 6375 break;
6377 6376 case ITASK_CMD_SEND_STATUS:
6378 6377 /* case ITASK_CMD_XFER_DATA: */
6379 6378 break;
6380 6379 }
6381 6380 mutex_enter(&w->worker_lock);
6382 6381 if (dec_qdepth) {
6383 6382 w->worker_queue_depth--;
6384 6383 }
6385 6384 }
6386 6385 if ((w->worker_flags & STMF_WORKER_TERMINATE) && (wait_timer == 0)) {
6387 6386 if (w->worker_ref_count == 0)
6388 6387 goto stmf_worker_loop;
6389 6388 else {
6390 6389 wait_timer = ddi_get_lbolt() + 1;
6391 6390 wait_delta = 1;
6392 6391 }
6393 6392 }
6394 6393 w->worker_flags &= ~STMF_WORKER_ACTIVE;
6395 6394 if (wait_timer) {
6396 6395 DTRACE_PROBE1(worker__timed__sleep, stmf_worker_t, w);
6397 6396 (void) cv_reltimedwait(&w->worker_cv, &w->worker_lock,
6398 6397 wait_delta, TR_CLOCK_TICK);
6399 6398 } else {
6400 6399 DTRACE_PROBE1(worker__sleep, stmf_worker_t, w);
6401 6400 cv_wait(&w->worker_cv, &w->worker_lock);
6402 6401 }
6403 6402 DTRACE_PROBE1(worker__wakeup, stmf_worker_t, w);
6404 6403 w->worker_flags |= STMF_WORKER_ACTIVE;
6405 6404 goto stmf_worker_loop;
6406 6405 }
6407 6406
6408 6407 void
6409 6408 stmf_worker_mgmt()
6410 6409 {
6411 6410 int i;
6412 6411 int workers_needed;
6413 6412 uint32_t qd;
6414 6413 clock_t tps, d = 0;
6415 6414 uint32_t cur_max_ntasks = 0;
6416 6415 stmf_worker_t *w;
6417 6416
6418 6417 /* Check if we are trying to increase the # of threads */
6419 6418 for (i = stmf_nworkers_cur; i < stmf_nworkers_needed; i++) {
6420 6419 if (stmf_workers[i].worker_flags & STMF_WORKER_STARTED) {
6421 6420 stmf_nworkers_cur++;
6422 6421 stmf_nworkers_accepting_cmds++;
6423 6422 } else {
6424 6423 /* Wait for transition to complete */
6425 6424 return;
6426 6425 }
6427 6426 }
6428 6427 /* Check if we are trying to decrease the # of workers */
6429 6428 for (i = (stmf_nworkers_cur - 1); i >= stmf_nworkers_needed; i--) {
6430 6429 if ((stmf_workers[i].worker_flags & STMF_WORKER_STARTED) == 0) {
6431 6430 stmf_nworkers_cur--;
6432 6431 /*
6433 6432 * stmf_nworkers_accepting_cmds has already been
6434 6433 * updated by the request to reduce the # of workers.
6435 6434 */
6436 6435 } else {
6437 6436 /* Wait for transition to complete */
6438 6437 return;
6439 6438 }
6440 6439 }
6441 6440 /* Check if we are being asked to quit */
6442 6441 if (stmf_workers_state != STMF_WORKERS_ENABLED) {
6443 6442 if (stmf_nworkers_cur) {
6444 6443 workers_needed = 0;
6445 6444 goto worker_mgmt_trigger_change;
6446 6445 }
6447 6446 return;
6448 6447 }
6449 6448 /* Check if we are starting */
6450 6449 if (stmf_nworkers_cur < stmf_i_min_nworkers) {
6451 6450 workers_needed = stmf_i_min_nworkers;
6452 6451 goto worker_mgmt_trigger_change;
6453 6452 }
6454 6453
6455 6454 tps = drv_usectohz(1 * 1000 * 1000);
6456 6455 if ((stmf_wm_last != 0) &&
6457 6456 ((d = ddi_get_lbolt() - stmf_wm_last) > tps)) {
6458 6457 qd = 0;
6459 6458 for (i = 0; i < stmf_nworkers_accepting_cmds; i++) {
6460 6459 qd += stmf_workers[i].worker_max_qdepth_pu;
6461 6460 stmf_workers[i].worker_max_qdepth_pu = 0;
6462 6461 if (stmf_workers[i].worker_max_sys_qdepth_pu >
6463 6462 cur_max_ntasks) {
6464 6463 cur_max_ntasks =
6465 6464 stmf_workers[i].worker_max_sys_qdepth_pu;
6466 6465 }
6467 6466 stmf_workers[i].worker_max_sys_qdepth_pu = 0;
6468 6467 }
6469 6468 }
6470 6469 stmf_wm_last = ddi_get_lbolt();
6471 6470 if (d <= tps) {
6472 6471 /* still ramping up */
6473 6472 return;
6474 6473 }
6475 6474 /* max qdepth cannot be more than max tasks */
6476 6475 if (qd > cur_max_ntasks)
6477 6476 qd = cur_max_ntasks;
6478 6477
6479 6478 /* See if we have more workers */
6480 6479 if (qd < stmf_nworkers_accepting_cmds) {
6481 6480 /*
6482 6481 * Since we dont reduce the worker count right away, monitor
6483 6482 * the highest load during the scale_down_delay.
6484 6483 */
6485 6484 if (qd > stmf_worker_scale_down_qd)
6486 6485 stmf_worker_scale_down_qd = qd;
6487 6486 if (stmf_worker_scale_down_timer == 0) {
6488 6487 stmf_worker_scale_down_timer = ddi_get_lbolt() +
6489 6488 drv_usectohz(stmf_worker_scale_down_delay *
6490 6489 1000 * 1000);
6491 6490 return;
6492 6491 }
6493 6492 if (ddi_get_lbolt() < stmf_worker_scale_down_timer) {
6494 6493 return;
6495 6494 }
6496 6495 /* Its time to reduce the workers */
6497 6496 if (stmf_worker_scale_down_qd < stmf_i_min_nworkers)
6498 6497 stmf_worker_scale_down_qd = stmf_i_min_nworkers;
6499 6498 if (stmf_worker_scale_down_qd > stmf_i_max_nworkers)
6500 6499 stmf_worker_scale_down_qd = stmf_i_max_nworkers;
6501 6500 if (stmf_worker_scale_down_qd == stmf_nworkers_cur)
6502 6501 return;
6503 6502 workers_needed = stmf_worker_scale_down_qd;
6504 6503 stmf_worker_scale_down_qd = 0;
6505 6504 goto worker_mgmt_trigger_change;
6506 6505 }
6507 6506 stmf_worker_scale_down_qd = 0;
6508 6507 stmf_worker_scale_down_timer = 0;
6509 6508 if (qd > stmf_i_max_nworkers)
6510 6509 qd = stmf_i_max_nworkers;
6511 6510 if (qd < stmf_i_min_nworkers)
6512 6511 qd = stmf_i_min_nworkers;
6513 6512 if (qd == stmf_nworkers_cur)
6514 6513 return;
6515 6514 workers_needed = qd;
6516 6515 goto worker_mgmt_trigger_change;
6517 6516
6518 6517 /* NOTREACHED */
6519 6518 return;
6520 6519
6521 6520 worker_mgmt_trigger_change:
6522 6521 ASSERT(workers_needed != stmf_nworkers_cur);
6523 6522 if (workers_needed > stmf_nworkers_cur) {
6524 6523 stmf_nworkers_needed = workers_needed;
6525 6524 for (i = stmf_nworkers_cur; i < workers_needed; i++) {
6526 6525 w = &stmf_workers[i];
6527 6526 w->worker_tid = thread_create(NULL, 0, stmf_worker_task,
6528 6527 (void *)&stmf_workers[i], 0, &p0, TS_RUN,
6529 6528 minclsyspri);
6530 6529 }
6531 6530 return;
6532 6531 }
6533 6532 /* At this point we know that we are decreasing the # of workers */
6534 6533 stmf_nworkers_accepting_cmds = workers_needed;
6535 6534 stmf_nworkers_needed = workers_needed;
6536 6535 /* Signal the workers that its time to quit */
6537 6536 for (i = (stmf_nworkers_cur - 1); i >= stmf_nworkers_needed; i--) {
6538 6537 w = &stmf_workers[i];
6539 6538 ASSERT(w && (w->worker_flags & STMF_WORKER_STARTED));
6540 6539 mutex_enter(&w->worker_lock);
6541 6540 w->worker_flags |= STMF_WORKER_TERMINATE;
6542 6541 if ((w->worker_flags & STMF_WORKER_ACTIVE) == 0)
6543 6542 cv_signal(&w->worker_cv);
6544 6543 mutex_exit(&w->worker_lock);
6545 6544 }
6546 6545 }
6547 6546
6548 6547 /*
6549 6548 * Fills out a dbuf from stmf_xfer_data_t (contained in the db_lu_private).
6550 6549 * If all the data has been filled out, frees the xd and makes
6551 6550 * db_lu_private NULL.
6552 6551 */
6553 6552 void
6554 6553 stmf_xd_to_dbuf(stmf_data_buf_t *dbuf, int set_rel_off)
6555 6554 {
6556 6555 stmf_xfer_data_t *xd;
6557 6556 uint8_t *p;
6558 6557 int i;
6559 6558 uint32_t s;
6560 6559
6561 6560 xd = (stmf_xfer_data_t *)dbuf->db_lu_private;
6562 6561 dbuf->db_data_size = 0;
6563 6562 if (set_rel_off)
6564 6563 dbuf->db_relative_offset = xd->size_done;
6565 6564 for (i = 0; i < dbuf->db_sglist_length; i++) {
6566 6565 s = min(xd->size_left, dbuf->db_sglist[i].seg_length);
6567 6566 p = &xd->buf[xd->size_done];
6568 6567 bcopy(p, dbuf->db_sglist[i].seg_addr, s);
6569 6568 xd->size_left -= s;
6570 6569 xd->size_done += s;
6571 6570 dbuf->db_data_size += s;
6572 6571 if (xd->size_left == 0) {
6573 6572 kmem_free(xd, xd->alloc_size);
6574 6573 dbuf->db_lu_private = NULL;
6575 6574 return;
6576 6575 }
6577 6576 }
6578 6577 }
6579 6578
6580 6579 /* ARGSUSED */
6581 6580 stmf_status_t
6582 6581 stmf_dlun0_task_alloc(scsi_task_t *task)
6583 6582 {
6584 6583 return (STMF_SUCCESS);
6585 6584 }
6586 6585
6587 6586 void
6588 6587 stmf_dlun0_new_task(scsi_task_t *task, stmf_data_buf_t *dbuf)
6589 6588 {
6590 6589 uint8_t *cdbp = (uint8_t *)&task->task_cdb[0];
6591 6590 stmf_i_scsi_session_t *iss;
6592 6591 uint32_t sz, minsz;
6593 6592 uint8_t *p;
6594 6593 stmf_xfer_data_t *xd;
6595 6594 uint8_t inq_page_length = 31;
6596 6595
6597 6596 if (task->task_mgmt_function) {
6598 6597 stmf_scsilib_handle_task_mgmt(task);
6599 6598 return;
6600 6599 }
6601 6600
6602 6601 switch (cdbp[0]) {
6603 6602 case SCMD_INQUIRY:
6604 6603 /*
6605 6604 * Basic protocol checks. In addition, only reply to
6606 6605 * standard inquiry. Otherwise, the LU provider needs
6607 6606 * to respond.
6608 6607 */
6609 6608
6610 6609 if (cdbp[2] || (cdbp[1] & 1) || cdbp[5]) {
6611 6610 stmf_scsilib_send_status(task, STATUS_CHECK,
6612 6611 STMF_SAA_INVALID_FIELD_IN_CDB);
6613 6612 return;
6614 6613 }
6615 6614
6616 6615 task->task_cmd_xfer_length =
6617 6616 (((uint32_t)cdbp[3]) << 8) | cdbp[4];
6618 6617
6619 6618 if (task->task_additional_flags &
6620 6619 TASK_AF_NO_EXPECTED_XFER_LENGTH) {
6621 6620 task->task_expected_xfer_length =
6622 6621 task->task_cmd_xfer_length;
6623 6622 }
6624 6623
6625 6624 sz = min(task->task_expected_xfer_length,
6626 6625 min(36, task->task_cmd_xfer_length));
6627 6626 minsz = 36;
6628 6627
6629 6628 if (sz == 0) {
6630 6629 stmf_scsilib_send_status(task, STATUS_GOOD, 0);
6631 6630 return;
6632 6631 }
6633 6632
6634 6633 if (dbuf && (dbuf->db_sglist[0].seg_length < 36)) {
6635 6634 /*
6636 6635 * Ignore any preallocated dbuf if the size is less
6637 6636 * than 36. It will be freed during the task_free.
6638 6637 */
6639 6638 dbuf = NULL;
6640 6639 }
6641 6640 if (dbuf == NULL)
6642 6641 dbuf = stmf_alloc_dbuf(task, minsz, &minsz, 0);
6643 6642 if ((dbuf == NULL) || (dbuf->db_sglist[0].seg_length < sz)) {
6644 6643 stmf_abort(STMF_QUEUE_TASK_ABORT, task,
6645 6644 STMF_ALLOC_FAILURE, NULL);
6646 6645 return;
6647 6646 }
6648 6647 dbuf->db_lu_private = NULL;
6649 6648
6650 6649 p = dbuf->db_sglist[0].seg_addr;
6651 6650
6652 6651 /*
6653 6652 * Standard inquiry handling only.
6654 6653 */
6655 6654
6656 6655 bzero(p, inq_page_length + 5);
6657 6656
6658 6657 p[0] = DPQ_SUPPORTED | DTYPE_UNKNOWN;
6659 6658 p[2] = 5;
6660 6659 p[3] = 0x12;
6661 6660 p[4] = inq_page_length;
6662 6661 p[6] = 0x80;
6663 6662
6664 6663 (void) strncpy((char *)p+8, "SUN ", 8);
6665 6664 (void) strncpy((char *)p+16, "COMSTAR ", 16);
6666 6665 (void) strncpy((char *)p+32, "1.0 ", 4);
6667 6666
6668 6667 dbuf->db_data_size = sz;
6669 6668 dbuf->db_relative_offset = 0;
6670 6669 dbuf->db_flags = DB_DIRECTION_TO_RPORT;
6671 6670 (void) stmf_xfer_data(task, dbuf, 0);
6672 6671
6673 6672 return;
6674 6673
6675 6674 case SCMD_REPORT_LUNS:
6676 6675 task->task_cmd_xfer_length =
6677 6676 ((((uint32_t)task->task_cdb[6]) << 24) |
6678 6677 (((uint32_t)task->task_cdb[7]) << 16) |
6679 6678 (((uint32_t)task->task_cdb[8]) << 8) |
6680 6679 ((uint32_t)task->task_cdb[9]));
6681 6680
6682 6681 if (task->task_additional_flags &
6683 6682 TASK_AF_NO_EXPECTED_XFER_LENGTH) {
6684 6683 task->task_expected_xfer_length =
6685 6684 task->task_cmd_xfer_length;
6686 6685 }
6687 6686
6688 6687 sz = min(task->task_expected_xfer_length,
6689 6688 task->task_cmd_xfer_length);
6690 6689
6691 6690 if (sz < 16) {
6692 6691 stmf_scsilib_send_status(task, STATUS_CHECK,
6693 6692 STMF_SAA_INVALID_FIELD_IN_CDB);
6694 6693 return;
6695 6694 }
6696 6695
6697 6696 iss = (stmf_i_scsi_session_t *)
6698 6697 task->task_session->ss_stmf_private;
6699 6698 rw_enter(iss->iss_lockp, RW_WRITER);
6700 6699 xd = stmf_session_prepare_report_lun_data(iss->iss_sm);
6701 6700 rw_exit(iss->iss_lockp);
6702 6701
6703 6702 if (xd == NULL) {
6704 6703 stmf_abort(STMF_QUEUE_TASK_ABORT, task,
6705 6704 STMF_ALLOC_FAILURE, NULL);
6706 6705 return;
6707 6706 }
6708 6707
6709 6708 sz = min(sz, xd->size_left);
6710 6709 xd->size_left = sz;
6711 6710 minsz = min(512, sz);
6712 6711
6713 6712 if (dbuf == NULL)
6714 6713 dbuf = stmf_alloc_dbuf(task, sz, &minsz, 0);
6715 6714 if (dbuf == NULL) {
6716 6715 kmem_free(xd, xd->alloc_size);
6717 6716 stmf_abort(STMF_QUEUE_TASK_ABORT, task,
6718 6717 STMF_ALLOC_FAILURE, NULL);
6719 6718 return;
6720 6719 }
6721 6720 dbuf->db_lu_private = xd;
6722 6721 stmf_xd_to_dbuf(dbuf, 1);
6723 6722
6724 6723 atomic_and_32(&iss->iss_flags,
6725 6724 ~(ISS_LUN_INVENTORY_CHANGED | ISS_GOT_INITIAL_LUNS));
6726 6725 dbuf->db_flags = DB_DIRECTION_TO_RPORT;
6727 6726 (void) stmf_xfer_data(task, dbuf, 0);
6728 6727 return;
6729 6728 }
6730 6729
6731 6730 stmf_scsilib_send_status(task, STATUS_CHECK, STMF_SAA_INVALID_OPCODE);
6732 6731 }
6733 6732
6734 6733 void
6735 6734 stmf_dlun0_dbuf_done(scsi_task_t *task, stmf_data_buf_t *dbuf)
6736 6735 {
6737 6736 stmf_i_scsi_task_t *itask =
6738 6737 (stmf_i_scsi_task_t *)task->task_stmf_private;
6739 6738
6740 6739 if (dbuf->db_xfer_status != STMF_SUCCESS) {
6741 6740 stmf_abort(STMF_QUEUE_TASK_ABORT, task,
6742 6741 dbuf->db_xfer_status, NULL);
6743 6742 return;
6744 6743 }
6745 6744 task->task_nbytes_transferred += dbuf->db_data_size;
6746 6745 if (dbuf->db_lu_private) {
6747 6746 /* There is more */
6748 6747 stmf_xd_to_dbuf(dbuf, 1);
6749 6748 (void) stmf_xfer_data(task, dbuf, 0);
6750 6749 return;
6751 6750 }
6752 6751
6753 6752 stmf_free_dbuf(task, dbuf);
6754 6753 /*
6755 6754 * If this is a proxy task, it will need to be completed from the
6756 6755 * proxy port provider. This message lets pppt know that the xfer
6757 6756 * is complete. When we receive the status from pppt, we will
6758 6757 * then relay that status back to the lport.
6759 6758 */
6760 6759 if (itask->itask_flags & ITASK_PROXY_TASK) {
6761 6760 stmf_ic_msg_t *ic_xfer_done_msg = NULL;
6762 6761 stmf_status_t ic_ret = STMF_FAILURE;
6763 6762 uint64_t session_msg_id;
6764 6763 mutex_enter(&stmf_state.stmf_lock);
6765 6764 session_msg_id = stmf_proxy_msg_id++;
6766 6765 mutex_exit(&stmf_state.stmf_lock);
6767 6766 /* send xfer done status to pppt */
6768 6767 ic_xfer_done_msg = ic_scsi_data_xfer_done_msg_alloc(
6769 6768 itask->itask_proxy_msg_id,
6770 6769 task->task_session->ss_session_id,
6771 6770 STMF_SUCCESS, session_msg_id);
6772 6771 if (ic_xfer_done_msg) {
6773 6772 ic_ret = ic_tx_msg(ic_xfer_done_msg);
6774 6773 if (ic_ret != STMF_IC_MSG_SUCCESS) {
6775 6774 cmn_err(CE_WARN, "unable to xmit session msg");
6776 6775 }
6777 6776 }
6778 6777 /* task will be completed from pppt */
6779 6778 return;
6780 6779 }
6781 6780 stmf_scsilib_send_status(task, STATUS_GOOD, 0);
6782 6781 }
6783 6782
6784 6783 /* ARGSUSED */
6785 6784 void
6786 6785 stmf_dlun0_status_done(scsi_task_t *task)
6787 6786 {
6788 6787 }
6789 6788
6790 6789 /* ARGSUSED */
6791 6790 void
6792 6791 stmf_dlun0_task_free(scsi_task_t *task)
6793 6792 {
6794 6793 }
6795 6794
6796 6795 /* ARGSUSED */
6797 6796 stmf_status_t
6798 6797 stmf_dlun0_abort(struct stmf_lu *lu, int abort_cmd, void *arg, uint32_t flags)
6799 6798 {
6800 6799 scsi_task_t *task = (scsi_task_t *)arg;
6801 6800 stmf_i_scsi_task_t *itask =
6802 6801 (stmf_i_scsi_task_t *)task->task_stmf_private;
6803 6802 stmf_i_lu_t *ilu = (stmf_i_lu_t *)task->task_lu->lu_stmf_private;
6804 6803 int i;
6805 6804 uint8_t map;
6806 6805
6807 6806 if ((task->task_mgmt_function) && (itask->itask_flags &
6808 6807 (ITASK_CAUSING_LU_RESET | ITASK_CAUSING_TARGET_RESET))) {
6809 6808 switch (task->task_mgmt_function) {
6810 6809 case TM_ABORT_TASK:
6811 6810 case TM_ABORT_TASK_SET:
6812 6811 case TM_CLEAR_TASK_SET:
6813 6812 case TM_LUN_RESET:
6814 6813 atomic_and_32(&ilu->ilu_flags, ~ILU_RESET_ACTIVE);
6815 6814 break;
6816 6815 case TM_TARGET_RESET:
6817 6816 case TM_TARGET_COLD_RESET:
6818 6817 case TM_TARGET_WARM_RESET:
6819 6818 stmf_abort_target_reset(task);
6820 6819 break;
6821 6820 }
6822 6821 return (STMF_ABORT_SUCCESS);
6823 6822 }
6824 6823
6825 6824 /*
6826 6825 * OK so its not a task mgmt. Make sure we free any xd sitting
6827 6826 * inside any dbuf.
6828 6827 */
6829 6828 if ((map = itask->itask_allocated_buf_map) != 0) {
6830 6829 for (i = 0; i < 4; i++) {
6831 6830 if ((map & 1) &&
6832 6831 ((itask->itask_dbufs[i])->db_lu_private)) {
6833 6832 stmf_xfer_data_t *xd;
6834 6833 stmf_data_buf_t *dbuf;
6835 6834
6836 6835 dbuf = itask->itask_dbufs[i];
6837 6836 xd = (stmf_xfer_data_t *)dbuf->db_lu_private;
6838 6837 dbuf->db_lu_private = NULL;
6839 6838 kmem_free(xd, xd->alloc_size);
6840 6839 }
6841 6840 map >>= 1;
6842 6841 }
6843 6842 }
6844 6843 return (STMF_ABORT_SUCCESS);
6845 6844 }
6846 6845
6847 6846 void
6848 6847 stmf_dlun0_task_poll(struct scsi_task *task)
6849 6848 {
6850 6849 /* Right now we only do this for handling task management functions */
6851 6850 ASSERT(task->task_mgmt_function);
6852 6851
6853 6852 switch (task->task_mgmt_function) {
6854 6853 case TM_ABORT_TASK:
6855 6854 case TM_ABORT_TASK_SET:
6856 6855 case TM_CLEAR_TASK_SET:
6857 6856 case TM_LUN_RESET:
6858 6857 (void) stmf_lun_reset_poll(task->task_lu, task, 0);
6859 6858 return;
6860 6859 case TM_TARGET_RESET:
6861 6860 case TM_TARGET_COLD_RESET:
6862 6861 case TM_TARGET_WARM_RESET:
6863 6862 stmf_target_reset_poll(task);
6864 6863 return;
6865 6864 }
6866 6865 }
6867 6866
6868 6867 /* ARGSUSED */
6869 6868 void
6870 6869 stmf_dlun0_ctl(struct stmf_lu *lu, int cmd, void *arg)
6871 6870 {
6872 6871 /* This function will never be called */
6873 6872 cmn_err(CE_WARN, "stmf_dlun0_ctl called with cmd %x", cmd);
6874 6873 }
6875 6874
6876 6875 void
6877 6876 stmf_dlun_init()
6878 6877 {
6879 6878 stmf_i_lu_t *ilu;
6880 6879
6881 6880 dlun0 = stmf_alloc(STMF_STRUCT_STMF_LU, 0, 0);
6882 6881 dlun0->lu_task_alloc = stmf_dlun0_task_alloc;
6883 6882 dlun0->lu_new_task = stmf_dlun0_new_task;
6884 6883 dlun0->lu_dbuf_xfer_done = stmf_dlun0_dbuf_done;
6885 6884 dlun0->lu_send_status_done = stmf_dlun0_status_done;
6886 6885 dlun0->lu_task_free = stmf_dlun0_task_free;
6887 6886 dlun0->lu_abort = stmf_dlun0_abort;
6888 6887 dlun0->lu_task_poll = stmf_dlun0_task_poll;
6889 6888 dlun0->lu_ctl = stmf_dlun0_ctl;
6890 6889
6891 6890 ilu = (stmf_i_lu_t *)dlun0->lu_stmf_private;
6892 6891 ilu->ilu_cur_task_cntr = &ilu->ilu_task_cntr1;
6893 6892 }
6894 6893
6895 6894 stmf_status_t
6896 6895 stmf_dlun_fini()
6897 6896 {
6898 6897 stmf_i_lu_t *ilu;
6899 6898
6900 6899 ilu = (stmf_i_lu_t *)dlun0->lu_stmf_private;
6901 6900
6902 6901 ASSERT(ilu->ilu_ntasks == ilu->ilu_ntasks_free);
6903 6902 if (ilu->ilu_ntasks) {
6904 6903 stmf_i_scsi_task_t *itask, *nitask;
6905 6904
6906 6905 nitask = ilu->ilu_tasks;
6907 6906 do {
6908 6907 itask = nitask;
6909 6908 nitask = itask->itask_lu_next;
6910 6909 dlun0->lu_task_free(itask->itask_task);
6911 6910 stmf_free(itask->itask_task);
6912 6911 } while (nitask != NULL);
6913 6912
6914 6913 }
6915 6914 stmf_free(dlun0);
6916 6915 return (STMF_SUCCESS);
6917 6916 }
6918 6917
6919 6918 void
6920 6919 stmf_abort_target_reset(scsi_task_t *task)
6921 6920 {
6922 6921 stmf_i_scsi_session_t *iss = (stmf_i_scsi_session_t *)
6923 6922 task->task_session->ss_stmf_private;
6924 6923 stmf_lun_map_t *lm;
6925 6924 stmf_lun_map_ent_t *lm_ent;
6926 6925 stmf_i_lu_t *ilu;
6927 6926 int i;
6928 6927
6929 6928 rw_enter(iss->iss_lockp, RW_READER);
6930 6929 lm = iss->iss_sm;
6931 6930 for (i = 0; i < lm->lm_nentries; i++) {
6932 6931 if (lm->lm_plus[i] == NULL)
6933 6932 continue;
6934 6933 lm_ent = (stmf_lun_map_ent_t *)lm->lm_plus[i];
6935 6934 ilu = (stmf_i_lu_t *)lm_ent->ent_lu->lu_stmf_private;
6936 6935 if (ilu->ilu_flags & ILU_RESET_ACTIVE) {
6937 6936 atomic_and_32(&ilu->ilu_flags, ~ILU_RESET_ACTIVE);
6938 6937 }
6939 6938 }
6940 6939 atomic_and_32(&iss->iss_flags, ~ISS_RESET_ACTIVE);
6941 6940 rw_exit(iss->iss_lockp);
6942 6941 }
6943 6942
6944 6943 /*
6945 6944 * The return value is only used by function managing target reset.
6946 6945 */
6947 6946 stmf_status_t
6948 6947 stmf_lun_reset_poll(stmf_lu_t *lu, struct scsi_task *task, int target_reset)
6949 6948 {
6950 6949 stmf_i_lu_t *ilu = (stmf_i_lu_t *)lu->lu_stmf_private;
6951 6950 int ntasks_pending;
6952 6951
6953 6952 ntasks_pending = ilu->ilu_ntasks - ilu->ilu_ntasks_free;
6954 6953 /*
6955 6954 * This function is also used during Target reset. The idea is that
6956 6955 * once all the commands are aborted, call the LU's reset entry
6957 6956 * point (abort entry point with a reset flag). But if this Task
6958 6957 * mgmt is running on this LU then all the tasks cannot be aborted.
6959 6958 * one task (this task) will still be running which is OK.
6960 6959 */
6961 6960 if ((ntasks_pending == 0) || ((task->task_lu == lu) &&
6962 6961 (ntasks_pending == 1))) {
6963 6962 stmf_status_t ret;
6964 6963
6965 6964 if ((task->task_mgmt_function == TM_LUN_RESET) ||
6966 6965 (task->task_mgmt_function == TM_TARGET_RESET) ||
6967 6966 (task->task_mgmt_function == TM_TARGET_WARM_RESET) ||
6968 6967 (task->task_mgmt_function == TM_TARGET_COLD_RESET)) {
6969 6968 ret = lu->lu_abort(lu, STMF_LU_RESET_STATE, task, 0);
6970 6969 } else {
6971 6970 ret = STMF_SUCCESS;
6972 6971 }
6973 6972 if (ret == STMF_SUCCESS) {
6974 6973 atomic_and_32(&ilu->ilu_flags, ~ILU_RESET_ACTIVE);
6975 6974 }
6976 6975 if (target_reset) {
6977 6976 return (ret);
6978 6977 }
6979 6978 if (ret == STMF_SUCCESS) {
6980 6979 stmf_scsilib_send_status(task, STATUS_GOOD, 0);
6981 6980 return (ret);
6982 6981 }
6983 6982 if (ret != STMF_BUSY) {
6984 6983 stmf_abort(STMF_QUEUE_TASK_ABORT, task, ret, NULL);
6985 6984 return (ret);
6986 6985 }
6987 6986 }
6988 6987
6989 6988 if (target_reset) {
6990 6989 /* Tell target reset polling code that we are not done */
6991 6990 return (STMF_BUSY);
6992 6991 }
6993 6992
6994 6993 if (stmf_task_poll_lu(task, ITASK_DEFAULT_POLL_TIMEOUT)
6995 6994 != STMF_SUCCESS) {
6996 6995 stmf_abort(STMF_QUEUE_TASK_ABORT, task,
6997 6996 STMF_ALLOC_FAILURE, NULL);
6998 6997 return (STMF_SUCCESS);
6999 6998 }
7000 6999
7001 7000 return (STMF_SUCCESS);
7002 7001 }
7003 7002
7004 7003 void
7005 7004 stmf_target_reset_poll(struct scsi_task *task)
7006 7005 {
7007 7006 stmf_i_scsi_session_t *iss = (stmf_i_scsi_session_t *)
7008 7007 task->task_session->ss_stmf_private;
7009 7008 stmf_lun_map_t *lm;
7010 7009 stmf_lun_map_ent_t *lm_ent;
7011 7010 stmf_i_lu_t *ilu;
7012 7011 stmf_status_t ret;
7013 7012 int i;
7014 7013 int not_done = 0;
7015 7014
7016 7015 ASSERT(iss->iss_flags & ISS_RESET_ACTIVE);
7017 7016
7018 7017 rw_enter(iss->iss_lockp, RW_READER);
7019 7018 lm = iss->iss_sm;
7020 7019 for (i = 0; i < lm->lm_nentries; i++) {
7021 7020 if (lm->lm_plus[i] == NULL)
7022 7021 continue;
7023 7022 lm_ent = (stmf_lun_map_ent_t *)lm->lm_plus[i];
7024 7023 ilu = (stmf_i_lu_t *)lm_ent->ent_lu->lu_stmf_private;
7025 7024 if (ilu->ilu_flags & ILU_RESET_ACTIVE) {
7026 7025 rw_exit(iss->iss_lockp);
7027 7026 ret = stmf_lun_reset_poll(lm_ent->ent_lu, task, 1);
7028 7027 rw_enter(iss->iss_lockp, RW_READER);
7029 7028 if (ret == STMF_SUCCESS)
7030 7029 continue;
7031 7030 not_done = 1;
7032 7031 if (ret != STMF_BUSY) {
7033 7032 rw_exit(iss->iss_lockp);
7034 7033 stmf_abort(STMF_QUEUE_TASK_ABORT, task,
7035 7034 STMF_ABORTED, NULL);
7036 7035 return;
7037 7036 }
7038 7037 }
7039 7038 }
7040 7039 rw_exit(iss->iss_lockp);
7041 7040
7042 7041 if (not_done) {
7043 7042 if (stmf_task_poll_lu(task, ITASK_DEFAULT_POLL_TIMEOUT)
7044 7043 != STMF_SUCCESS) {
7045 7044 stmf_abort(STMF_QUEUE_TASK_ABORT, task,
7046 7045 STMF_ALLOC_FAILURE, NULL);
7047 7046 return;
7048 7047 }
7049 7048 return;
7050 7049 }
7051 7050
7052 7051 atomic_and_32(&iss->iss_flags, ~ISS_RESET_ACTIVE);
7053 7052
7054 7053 stmf_scsilib_send_status(task, STATUS_GOOD, 0);
7055 7054 }
7056 7055
7057 7056 stmf_status_t
7058 7057 stmf_lu_add_event(stmf_lu_t *lu, int eventid)
7059 7058 {
7060 7059 stmf_i_lu_t *ilu = (stmf_i_lu_t *)lu->lu_stmf_private;
7061 7060
7062 7061 if ((eventid < 0) || (eventid >= STMF_MAX_NUM_EVENTS)) {
7063 7062 return (STMF_INVALID_ARG);
7064 7063 }
7065 7064
7066 7065 STMF_EVENT_ADD(ilu->ilu_event_hdl, eventid);
7067 7066 return (STMF_SUCCESS);
7068 7067 }
7069 7068
7070 7069 stmf_status_t
7071 7070 stmf_lu_remove_event(stmf_lu_t *lu, int eventid)
7072 7071 {
7073 7072 stmf_i_lu_t *ilu = (stmf_i_lu_t *)lu->lu_stmf_private;
7074 7073
7075 7074 if (eventid == STMF_EVENT_ALL) {
7076 7075 STMF_EVENT_CLEAR_ALL(ilu->ilu_event_hdl);
7077 7076 return (STMF_SUCCESS);
7078 7077 }
7079 7078
7080 7079 if ((eventid < 0) || (eventid >= STMF_MAX_NUM_EVENTS)) {
7081 7080 return (STMF_INVALID_ARG);
7082 7081 }
7083 7082
7084 7083 STMF_EVENT_REMOVE(ilu->ilu_event_hdl, eventid);
7085 7084 return (STMF_SUCCESS);
7086 7085 }
7087 7086
7088 7087 stmf_status_t
7089 7088 stmf_lport_add_event(stmf_local_port_t *lport, int eventid)
7090 7089 {
7091 7090 stmf_i_local_port_t *ilport =
7092 7091 (stmf_i_local_port_t *)lport->lport_stmf_private;
7093 7092
7094 7093 if ((eventid < 0) || (eventid >= STMF_MAX_NUM_EVENTS)) {
7095 7094 return (STMF_INVALID_ARG);
7096 7095 }
7097 7096
7098 7097 STMF_EVENT_ADD(ilport->ilport_event_hdl, eventid);
7099 7098 return (STMF_SUCCESS);
7100 7099 }
7101 7100
7102 7101 stmf_status_t
7103 7102 stmf_lport_remove_event(stmf_local_port_t *lport, int eventid)
7104 7103 {
7105 7104 stmf_i_local_port_t *ilport =
7106 7105 (stmf_i_local_port_t *)lport->lport_stmf_private;
7107 7106
7108 7107 if (eventid == STMF_EVENT_ALL) {
7109 7108 STMF_EVENT_CLEAR_ALL(ilport->ilport_event_hdl);
7110 7109 return (STMF_SUCCESS);
7111 7110 }
7112 7111
7113 7112 if ((eventid < 0) || (eventid >= STMF_MAX_NUM_EVENTS)) {
7114 7113 return (STMF_INVALID_ARG);
7115 7114 }
7116 7115
7117 7116 STMF_EVENT_REMOVE(ilport->ilport_event_hdl, eventid);
7118 7117 return (STMF_SUCCESS);
7119 7118 }
7120 7119
7121 7120 void
7122 7121 stmf_generate_lu_event(stmf_i_lu_t *ilu, int eventid, void *arg, uint32_t flags)
7123 7122 {
7124 7123 if (STMF_EVENT_ENABLED(ilu->ilu_event_hdl, eventid) &&
7125 7124 (ilu->ilu_lu->lu_event_handler != NULL)) {
7126 7125 ilu->ilu_lu->lu_event_handler(ilu->ilu_lu, eventid, arg, flags);
7127 7126 }
7128 7127 }
7129 7128
7130 7129 void
7131 7130 stmf_generate_lport_event(stmf_i_local_port_t *ilport, int eventid, void *arg,
7132 7131 uint32_t flags)
7133 7132 {
7134 7133 if (STMF_EVENT_ENABLED(ilport->ilport_event_hdl, eventid) &&
7135 7134 (ilport->ilport_lport->lport_event_handler != NULL)) {
7136 7135 ilport->ilport_lport->lport_event_handler(
7137 7136 ilport->ilport_lport, eventid, arg, flags);
7138 7137 }
7139 7138 }
7140 7139
7141 7140 /*
7142 7141 * With the possibility of having multiple itl sessions pointing to the
7143 7142 * same itl_kstat_info, the ilu_kstat_lock mutex is used to synchronize
7144 7143 * the kstat update of the ilu_kstat_io, itl_kstat_taskq and itl_kstat_lu_xfer
7145 7144 * statistics.
7146 7145 */
7147 7146 void
7148 7147 stmf_itl_task_start(stmf_i_scsi_task_t *itask)
7149 7148 {
7150 7149 stmf_itl_data_t *itl = itask->itask_itl_datap;
7151 7150 scsi_task_t *task = itask->itask_task;
7152 7151 stmf_i_lu_t *ilu;
7153 7152
7154 7153 if (itl == NULL || task->task_lu == dlun0)
7155 7154 return;
7156 7155 ilu = (stmf_i_lu_t *)task->task_lu->lu_stmf_private;
7157 7156 itask->itask_start_timestamp = gethrtime();
7158 7157 if (ilu->ilu_kstat_io != NULL) {
7159 7158 mutex_enter(ilu->ilu_kstat_io->ks_lock);
7160 7159 stmf_update_kstat_lu_q(itask->itask_task, kstat_waitq_enter);
7161 7160 mutex_exit(ilu->ilu_kstat_io->ks_lock);
7162 7161 }
7163 7162
7164 7163 stmf_update_kstat_lport_q(itask->itask_task, kstat_waitq_enter);
7165 7164 }
7166 7165
7167 7166 void
7168 7167 stmf_itl_lu_new_task(stmf_i_scsi_task_t *itask)
7169 7168 {
7170 7169 stmf_itl_data_t *itl = itask->itask_itl_datap;
7171 7170 scsi_task_t *task = itask->itask_task;
7172 7171 stmf_i_lu_t *ilu;
7173 7172
7174 7173 if (itl == NULL || task->task_lu == dlun0)
7175 7174 return;
7176 7175 ilu = (stmf_i_lu_t *)task->task_lu->lu_stmf_private;
7177 7176 if (ilu->ilu_kstat_io != NULL) {
7178 7177 mutex_enter(ilu->ilu_kstat_io->ks_lock);
7179 7178 stmf_update_kstat_lu_q(itask->itask_task, kstat_waitq_to_runq);
7180 7179 mutex_exit(ilu->ilu_kstat_io->ks_lock);
7181 7180 }
7182 7181
7183 7182 stmf_update_kstat_lport_q(itask->itask_task, kstat_waitq_to_runq);
7184 7183 }
7185 7184
7186 7185 void
7187 7186 stmf_itl_task_done(stmf_i_scsi_task_t *itask)
7188 7187 {
7189 7188 stmf_itl_data_t *itl = itask->itask_itl_datap;
7190 7189 scsi_task_t *task = itask->itask_task;
7191 7190 stmf_i_lu_t *ilu;
7192 7191
7193 7192 itask->itask_done_timestamp = gethrtime();
7194 7193
7195 7194 if (itl == NULL || task->task_lu == dlun0)
7196 7195 return;
7197 7196 ilu = (stmf_i_lu_t *)task->task_lu->lu_stmf_private;
7198 7197
7199 7198 if (ilu->ilu_kstat_io == NULL)
7200 7199 return;
7201 7200
7202 7201 mutex_enter(ilu->ilu_kstat_io->ks_lock);
7203 7202
7204 7203 if (itask->itask_flags & ITASK_KSTAT_IN_RUNQ) {
7205 7204 stmf_update_kstat_lu_q(task, kstat_runq_exit);
7206 7205 mutex_exit(ilu->ilu_kstat_io->ks_lock);
7207 7206 stmf_update_kstat_lport_q(task, kstat_runq_exit);
7208 7207 } else {
7209 7208 stmf_update_kstat_lu_q(task, kstat_waitq_exit);
7210 7209 mutex_exit(ilu->ilu_kstat_io->ks_lock);
7211 7210 stmf_update_kstat_lport_q(task, kstat_waitq_exit);
7212 7211 }
7213 7212 }
7214 7213
7215 7214 static void
7216 7215 stmf_lport_xfer_start(stmf_i_scsi_task_t *itask, stmf_data_buf_t *dbuf)
7217 7216 {
7218 7217 stmf_itl_data_t *itl = itask->itask_itl_datap;
7219 7218
7220 7219 if (itl == NULL)
7221 7220 return;
7222 7221
7223 7222 DTRACE_PROBE2(scsi__xfer__start, scsi_task_t *, itask->itask_task,
7224 7223 stmf_data_buf_t *, dbuf);
7225 7224
7226 7225 dbuf->db_xfer_start_timestamp = gethrtime();
7227 7226 }
7228 7227
7229 7228 static void
7230 7229 stmf_lport_xfer_done(stmf_i_scsi_task_t *itask, stmf_data_buf_t *dbuf)
7231 7230 {
7232 7231 stmf_itl_data_t *itl = itask->itask_itl_datap;
7233 7232 hrtime_t elapsed_time;
7234 7233 uint64_t xfer_size;
7235 7234
7236 7235 if (itl == NULL)
7237 7236 return;
7238 7237
7239 7238 xfer_size = (dbuf->db_xfer_status == STMF_SUCCESS) ?
7240 7239 dbuf->db_data_size : 0;
7241 7240
7242 7241 elapsed_time = gethrtime() - dbuf->db_xfer_start_timestamp;
7243 7242 if (dbuf->db_flags & DB_DIRECTION_TO_RPORT) {
7244 7243 atomic_add_64((uint64_t *)&itask->itask_lport_read_time,
7245 7244 elapsed_time);
7246 7245 atomic_add_64((uint64_t *)&itask->itask_read_xfer,
7247 7246 xfer_size);
7248 7247 } else {
7249 7248 atomic_add_64((uint64_t *)&itask->itask_lport_write_time,
7250 7249 elapsed_time);
7251 7250 atomic_add_64((uint64_t *)&itask->itask_write_xfer,
7252 7251 xfer_size);
7253 7252 }
7254 7253
7255 7254 DTRACE_PROBE3(scsi__xfer__end, scsi_task_t *, itask->itask_task,
7256 7255 stmf_data_buf_t *, dbuf, hrtime_t, elapsed_time);
7257 7256
7258 7257 dbuf->db_xfer_start_timestamp = 0;
7259 7258 }
7260 7259
7261 7260 void
7262 7261 stmf_svc_init()
7263 7262 {
7264 7263 if (stmf_state.stmf_svc_flags & STMF_SVC_STARTED)
7265 7264 return;
7266 7265 stmf_state.stmf_svc_tailp = &stmf_state.stmf_svc_active;
7267 7266 stmf_state.stmf_svc_taskq = ddi_taskq_create(0, "STMF_SVC_TASKQ", 1,
7268 7267 TASKQ_DEFAULTPRI, 0);
7269 7268 (void) ddi_taskq_dispatch(stmf_state.stmf_svc_taskq,
7270 7269 stmf_svc, 0, DDI_SLEEP);
7271 7270 }
7272 7271
7273 7272 stmf_status_t
7274 7273 stmf_svc_fini()
7275 7274 {
7276 7275 uint32_t i;
7277 7276
7278 7277 mutex_enter(&stmf_state.stmf_lock);
7279 7278 if (stmf_state.stmf_svc_flags & STMF_SVC_STARTED) {
7280 7279 stmf_state.stmf_svc_flags |= STMF_SVC_TERMINATE;
7281 7280 cv_signal(&stmf_state.stmf_cv);
7282 7281 }
7283 7282 mutex_exit(&stmf_state.stmf_lock);
7284 7283
7285 7284 /* Wait for 5 seconds */
7286 7285 for (i = 0; i < 500; i++) {
7287 7286 if (stmf_state.stmf_svc_flags & STMF_SVC_STARTED)
7288 7287 delay(drv_usectohz(10000));
7289 7288 else
7290 7289 break;
7291 7290 }
7292 7291 if (i == 500)
7293 7292 return (STMF_BUSY);
7294 7293
7295 7294 ddi_taskq_destroy(stmf_state.stmf_svc_taskq);
7296 7295
7297 7296 return (STMF_SUCCESS);
7298 7297 }
7299 7298
7300 7299 struct stmf_svc_clocks {
7301 7300 clock_t drain_start, drain_next;
7302 7301 clock_t timing_start, timing_next;
7303 7302 clock_t worker_delay;
7304 7303 };
7305 7304
7306 7305 /* ARGSUSED */
7307 7306 void
7308 7307 stmf_svc(void *arg)
7309 7308 {
7310 7309 stmf_svc_req_t *req;
7311 7310 stmf_lu_t *lu;
7312 7311 stmf_i_lu_t *ilu;
7313 7312 stmf_local_port_t *lport;
7314 7313 struct stmf_svc_clocks clks = { 0 };
7315 7314
7316 7315 mutex_enter(&stmf_state.stmf_lock);
7317 7316 stmf_state.stmf_svc_flags |= STMF_SVC_STARTED | STMF_SVC_ACTIVE;
7318 7317
7319 7318 while (!(stmf_state.stmf_svc_flags & STMF_SVC_TERMINATE)) {
7320 7319 if (stmf_state.stmf_svc_active == NULL) {
7321 7320 stmf_svc_timeout(&clks);
7322 7321 continue;
7323 7322 }
7324 7323
7325 7324 /*
7326 7325 * Pop the front request from the active list. After this,
7327 7326 * the request will no longer be referenced by global state,
7328 7327 * so it should be safe to access it without holding the
7329 7328 * stmf state lock.
7330 7329 */
7331 7330 req = stmf_state.stmf_svc_active;
7332 7331 stmf_state.stmf_svc_active = req->svc_next;
7333 7332
7334 7333 if (stmf_state.stmf_svc_active == NULL)
7335 7334 stmf_state.stmf_svc_tailp = &stmf_state.stmf_svc_active;
7336 7335
7337 7336 switch (req->svc_cmd) {
7338 7337 case STMF_CMD_LPORT_ONLINE:
7339 7338 /* Fallthrough */
7340 7339 case STMF_CMD_LPORT_OFFLINE:
7341 7340 mutex_exit(&stmf_state.stmf_lock);
7342 7341 lport = (stmf_local_port_t *)req->svc_obj;
7343 7342 lport->lport_ctl(lport, req->svc_cmd, &req->svc_info);
7344 7343 break;
7345 7344 case STMF_CMD_LU_ONLINE:
7346 7345 mutex_exit(&stmf_state.stmf_lock);
7347 7346 lu = (stmf_lu_t *)req->svc_obj;
7348 7347 lu->lu_ctl(lu, req->svc_cmd, &req->svc_info);
7349 7348 break;
7350 7349 case STMF_CMD_LU_OFFLINE:
7351 7350 /* Remove all mappings of this LU */
7352 7351 stmf_session_lu_unmapall((stmf_lu_t *)req->svc_obj);
7353 7352 /* Kill all the pending I/Os for this LU */
7354 7353 mutex_exit(&stmf_state.stmf_lock);
7355 7354 stmf_task_lu_killall((stmf_lu_t *)req->svc_obj, NULL,
7356 7355 STMF_ABORTED);
7357 7356 lu = (stmf_lu_t *)req->svc_obj;
7358 7357 ilu = (stmf_i_lu_t *)lu->lu_stmf_private;
7359 7358 stmf_wait_ilu_tasks_finish(ilu);
7360 7359 lu->lu_ctl(lu, req->svc_cmd, &req->svc_info);
7361 7360 break;
7362 7361 default:
7363 7362 cmn_err(CE_PANIC, "stmf_svc: unknown cmd %d",
7364 7363 req->svc_cmd);
7365 7364 }
7366 7365
7367 7366 kmem_free(req, req->svc_req_alloc_size);
7368 7367 mutex_enter(&stmf_state.stmf_lock);
7369 7368 }
7370 7369
7371 7370 stmf_state.stmf_svc_flags &= ~(STMF_SVC_STARTED | STMF_SVC_ACTIVE);
7372 7371 mutex_exit(&stmf_state.stmf_lock);
7373 7372 }
7374 7373
7375 7374 static void
7376 7375 stmf_svc_timeout(struct stmf_svc_clocks *clks)
7377 7376 {
7378 7377 clock_t td;
7379 7378 stmf_i_local_port_t *ilport, *next_ilport;
7380 7379 stmf_i_scsi_session_t *iss;
7381 7380
7382 7381 ASSERT(mutex_owned(&stmf_state.stmf_lock));
7383 7382
7384 7383 td = drv_usectohz(20000);
7385 7384
7386 7385 /* Do timeouts */
7387 7386 if (stmf_state.stmf_nlus &&
7388 7387 ((!clks->timing_next) || (ddi_get_lbolt() >= clks->timing_next))) {
7389 7388 if (!stmf_state.stmf_svc_ilu_timing) {
7390 7389 /* we are starting a new round */
7391 7390 stmf_state.stmf_svc_ilu_timing =
7392 7391 stmf_state.stmf_ilulist;
7393 7392 clks->timing_start = ddi_get_lbolt();
7394 7393 }
7395 7394
7396 7395 stmf_check_ilu_timing();
7397 7396 if (!stmf_state.stmf_svc_ilu_timing) {
7398 7397 /* we finished a complete round */
7399 7398 clks->timing_next =
7400 7399 clks->timing_start + drv_usectohz(5*1000*1000);
7401 7400 } else {
7402 7401 /* we still have some ilu items to check */
7403 7402 clks->timing_next =
7404 7403 ddi_get_lbolt() + drv_usectohz(1*1000*1000);
7405 7404 }
7406 7405
7407 7406 if (stmf_state.stmf_svc_active)
7408 7407 return;
7409 7408 }
7410 7409
7411 7410 /* Check if there are free tasks to clear */
7412 7411 if (stmf_state.stmf_nlus &&
7413 7412 ((!clks->drain_next) || (ddi_get_lbolt() >= clks->drain_next))) {
7414 7413 if (!stmf_state.stmf_svc_ilu_draining) {
7415 7414 /* we are starting a new round */
7416 7415 stmf_state.stmf_svc_ilu_draining =
7417 7416 stmf_state.stmf_ilulist;
7418 7417 clks->drain_start = ddi_get_lbolt();
7419 7418 }
7420 7419
7421 7420 stmf_check_freetask();
7422 7421 if (!stmf_state.stmf_svc_ilu_draining) {
7423 7422 /* we finished a complete round */
7424 7423 clks->drain_next =
7425 7424 clks->drain_start + drv_usectohz(10*1000*1000);
7426 7425 } else {
7427 7426 /* we still have some ilu items to check */
7428 7427 clks->drain_next =
7429 7428 ddi_get_lbolt() + drv_usectohz(1*1000*1000);
7430 7429 }
7431 7430
7432 7431 if (stmf_state.stmf_svc_active)
7433 7432 return;
7434 7433 }
7435 7434
7436 7435 /* Check if we need to run worker_mgmt */
7437 7436 if (ddi_get_lbolt() > clks->worker_delay) {
7438 7437 stmf_worker_mgmt();
7439 7438 clks->worker_delay = ddi_get_lbolt() +
7440 7439 stmf_worker_mgmt_delay;
7441 7440 }
7442 7441
7443 7442 /* Check if any active session got its 1st LUN */
7444 7443 if (stmf_state.stmf_process_initial_luns) {
7445 7444 int stmf_level = 0;
7446 7445 int port_level;
7447 7446
7448 7447 for (ilport = stmf_state.stmf_ilportlist; ilport;
7449 7448 ilport = next_ilport) {
7450 7449 int ilport_lock_held;
7451 7450 next_ilport = ilport->ilport_next;
7452 7451
7453 7452 if ((ilport->ilport_flags &
7454 7453 ILPORT_SS_GOT_INITIAL_LUNS) == 0)
7455 7454 continue;
7456 7455
7457 7456 port_level = 0;
7458 7457 rw_enter(&ilport->ilport_lock, RW_READER);
7459 7458 ilport_lock_held = 1;
7460 7459
7461 7460 for (iss = ilport->ilport_ss_list; iss;
7462 7461 iss = iss->iss_next) {
7463 7462 if ((iss->iss_flags &
7464 7463 ISS_GOT_INITIAL_LUNS) == 0)
7465 7464 continue;
7466 7465
7467 7466 port_level++;
7468 7467 stmf_level++;
7469 7468 atomic_and_32(&iss->iss_flags,
7470 7469 ~ISS_GOT_INITIAL_LUNS);
7471 7470 atomic_or_32(&iss->iss_flags,
7472 7471 ISS_EVENT_ACTIVE);
7473 7472 rw_exit(&ilport->ilport_lock);
7474 7473 ilport_lock_held = 0;
7475 7474 mutex_exit(&stmf_state.stmf_lock);
7476 7475 stmf_generate_lport_event(ilport,
7477 7476 LPORT_EVENT_INITIAL_LUN_MAPPED,
7478 7477 iss->iss_ss, 0);
7479 7478 atomic_and_32(&iss->iss_flags,
7480 7479 ~ISS_EVENT_ACTIVE);
7481 7480 mutex_enter(&stmf_state.stmf_lock);
7482 7481 /*
7483 7482 * scan all the ilports again as the
7484 7483 * ilport list might have changed.
7485 7484 */
7486 7485 next_ilport = stmf_state.stmf_ilportlist;
7487 7486 break;
7488 7487 }
7489 7488
7490 7489 if (port_level == 0)
7491 7490 atomic_and_32(&ilport->ilport_flags,
7492 7491 ~ILPORT_SS_GOT_INITIAL_LUNS);
7493 7492 /* drop the lock if we are holding it. */
7494 7493 if (ilport_lock_held == 1)
7495 7494 rw_exit(&ilport->ilport_lock);
7496 7495
7497 7496 /* Max 4 session at a time */
7498 7497 if (stmf_level >= 4)
7499 7498 break;
7500 7499 }
7501 7500
7502 7501 if (stmf_level == 0)
7503 7502 stmf_state.stmf_process_initial_luns = 0;
7504 7503 }
7505 7504
7506 7505 stmf_state.stmf_svc_flags &= ~STMF_SVC_ACTIVE;
7507 7506 (void) cv_reltimedwait(&stmf_state.stmf_cv,
7508 7507 &stmf_state.stmf_lock, td, TR_CLOCK_TICK);
7509 7508 stmf_state.stmf_svc_flags |= STMF_SVC_ACTIVE;
7510 7509 }
7511 7510
7512 7511 /*
7513 7512 * Waits for ongoing I/O tasks to finish on an LU in preparation for
7514 7513 * the LU's offlining. The LU should already be in an Offlining state
7515 7514 * (otherwise I/O to the LU might never end). There is an additional
7516 7515 * enforcement of this via a deadman timer check.
7517 7516 */
7518 7517 static void
7519 7518 stmf_wait_ilu_tasks_finish(stmf_i_lu_t *ilu)
7520 7519 {
7521 7520 clock_t start, now, deadline;
7522 7521
7523 7522 start = now = ddi_get_lbolt();
7524 7523 deadline = start + drv_usectohz(stmf_io_deadman * 1000000llu);
7525 7524 mutex_enter(&ilu->ilu_task_lock);
7526 7525 while (ilu->ilu_ntasks != ilu->ilu_ntasks_free) {
7527 7526 (void) cv_timedwait(&ilu->ilu_offline_pending_cv,
7528 7527 &ilu->ilu_task_lock, deadline);
7529 7528 now = ddi_get_lbolt();
7530 7529 if (now > deadline) {
7531 7530 if (stmf_io_deadman_enabled) {
7532 7531 cmn_err(CE_PANIC, "stmf_svc: I/O deadman hit "
7533 7532 "on STMF_CMD_LU_OFFLINE after %d seconds",
7534 7533 stmf_io_deadman);
7535 7534 } else {
7536 7535 /* keep on spinning */
7537 7536 deadline = now + drv_usectohz(stmf_io_deadman *
7538 7537 1000000llu);
7539 7538 }
7540 7539 }
7541 7540 }
7542 7541 mutex_exit(&ilu->ilu_task_lock);
7543 7542 DTRACE_PROBE1(deadman__timeout__wait, clock_t, now - start);
7544 7543 }
7545 7544
7546 7545 void
7547 7546 stmf_svc_queue(int cmd, void *obj, stmf_state_change_info_t *info)
7548 7547 {
7549 7548 stmf_svc_req_t *req;
7550 7549 int s;
7551 7550
7552 7551 ASSERT(!mutex_owned(&stmf_state.stmf_lock));
7553 7552 s = sizeof (stmf_svc_req_t);
7554 7553 if (info->st_additional_info) {
7555 7554 s += strlen(info->st_additional_info) + 1;
7556 7555 }
7557 7556 req = kmem_zalloc(s, KM_SLEEP);
7558 7557
7559 7558 req->svc_cmd = cmd;
7560 7559 req->svc_obj = obj;
7561 7560 req->svc_info.st_rflags = info->st_rflags;
7562 7561 if (info->st_additional_info) {
7563 7562 req->svc_info.st_additional_info = (char *)(GET_BYTE_OFFSET(req,
7564 7563 sizeof (stmf_svc_req_t)));
7565 7564 (void) strcpy(req->svc_info.st_additional_info,
7566 7565 info->st_additional_info);
7567 7566 }
7568 7567 req->svc_req_alloc_size = s;
7569 7568 req->svc_next = NULL;
7570 7569
7571 7570 mutex_enter(&stmf_state.stmf_lock);
7572 7571 *stmf_state.stmf_svc_tailp = req;
7573 7572 stmf_state.stmf_svc_tailp = &req->svc_next;
7574 7573 if ((stmf_state.stmf_svc_flags & STMF_SVC_ACTIVE) == 0) {
7575 7574 cv_signal(&stmf_state.stmf_cv);
7576 7575 }
7577 7576 mutex_exit(&stmf_state.stmf_lock);
7578 7577 }
7579 7578
7580 7579 static void
7581 7580 stmf_svc_kill_obj_requests(void *obj)
7582 7581 {
7583 7582 stmf_svc_req_t *prev_req = NULL;
7584 7583 stmf_svc_req_t *next_req;
7585 7584 stmf_svc_req_t *req;
7586 7585
7587 7586 ASSERT(mutex_owned(&stmf_state.stmf_lock));
7588 7587
7589 7588 for (req = stmf_state.stmf_svc_active; req != NULL; req = next_req) {
7590 7589 next_req = req->svc_next;
7591 7590
7592 7591 if (req->svc_obj == obj) {
7593 7592 if (prev_req != NULL)
7594 7593 prev_req->svc_next = next_req;
7595 7594 else
7596 7595 stmf_state.stmf_svc_active = next_req;
7597 7596
7598 7597 if (next_req == NULL)
7599 7598 stmf_state.stmf_svc_tailp = (prev_req != NULL) ?
7600 7599 &prev_req->svc_next :
7601 7600 &stmf_state.stmf_svc_active;
7602 7601
7603 7602 kmem_free(req, req->svc_req_alloc_size);
7604 7603 } else {
7605 7604 prev_req = req;
7606 7605 }
7607 7606 }
7608 7607 }
7609 7608
7610 7609 void
7611 7610 stmf_trace(caddr_t ident, const char *fmt, ...)
7612 7611 {
7613 7612 va_list args;
7614 7613 char tbuf[160];
7615 7614 int len;
7616 7615
7617 7616 if (!stmf_trace_on)
7618 7617 return;
7619 7618 len = snprintf(tbuf, 158, "%s:%07lu: ", ident ? ident : "",
7620 7619 ddi_get_lbolt());
7621 7620 va_start(args, fmt);
7622 7621 len += vsnprintf(tbuf + len, 158 - len, fmt, args);
7623 7622 va_end(args);
7624 7623
7625 7624 if (len > 158) {
7626 7625 len = 158;
7627 7626 }
7628 7627 tbuf[len++] = '\n';
7629 7628 tbuf[len] = 0;
7630 7629
7631 7630 mutex_enter(&trace_buf_lock);
7632 7631 bcopy(tbuf, &stmf_trace_buf[trace_buf_curndx], len+1);
7633 7632 trace_buf_curndx += len;
7634 7633 if (trace_buf_curndx > (trace_buf_size - 320))
7635 7634 trace_buf_curndx = 0;
7636 7635 mutex_exit(&trace_buf_lock);
7637 7636 }
7638 7637
7639 7638 void
7640 7639 stmf_trace_clear()
7641 7640 {
7642 7641 if (!stmf_trace_on)
7643 7642 return;
7644 7643 mutex_enter(&trace_buf_lock);
7645 7644 trace_buf_curndx = 0;
7646 7645 if (trace_buf_size > 0)
7647 7646 stmf_trace_buf[0] = 0;
7648 7647 mutex_exit(&trace_buf_lock);
7649 7648 }
7650 7649
7651 7650 static void
7652 7651 stmf_abort_task_offline(scsi_task_t *task, int offline_lu, char *info)
7653 7652 {
7654 7653 stmf_state_change_info_t change_info;
7655 7654 void *ctl_private;
7656 7655 uint32_t ctl_cmd;
7657 7656 int msg = 0;
7658 7657
7659 7658 stmf_trace("FROM STMF", "abort_task_offline called for %s: %s",
7660 7659 offline_lu ? "LU" : "LPORT", info ? info : "no additional info");
7661 7660 change_info.st_additional_info = info;
7662 7661 if (offline_lu) {
7663 7662 change_info.st_rflags = STMF_RFLAG_RESET |
7664 7663 STMF_RFLAG_LU_ABORT;
7665 7664 ctl_private = task->task_lu;
7666 7665 if (((stmf_i_lu_t *)
7667 7666 task->task_lu->lu_stmf_private)->ilu_state ==
7668 7667 STMF_STATE_ONLINE) {
7669 7668 msg = 1;
7670 7669 }
7671 7670 ctl_cmd = STMF_CMD_LU_OFFLINE;
7672 7671 } else {
7673 7672 change_info.st_rflags = STMF_RFLAG_RESET |
7674 7673 STMF_RFLAG_LPORT_ABORT;
7675 7674 ctl_private = task->task_lport;
7676 7675 if (((stmf_i_local_port_t *)
7677 7676 task->task_lport->lport_stmf_private)->ilport_state ==
7678 7677 STMF_STATE_ONLINE) {
7679 7678 msg = 1;
7680 7679 }
7681 7680 ctl_cmd = STMF_CMD_LPORT_OFFLINE;
7682 7681 }
7683 7682
7684 7683 if (msg) {
7685 7684 stmf_trace(0, "Calling stmf_ctl to offline %s : %s",
7686 7685 offline_lu ? "LU" : "LPORT", info ? info :
7687 7686 "<no additional info>");
7688 7687 }
7689 7688 (void) stmf_ctl(ctl_cmd, ctl_private, &change_info);
7690 7689 }
7691 7690
7692 7691 static char
7693 7692 stmf_ctoi(char c)
7694 7693 {
7695 7694 if ((c >= '0') && (c <= '9'))
7696 7695 c -= '0';
7697 7696 else if ((c >= 'A') && (c <= 'F'))
7698 7697 c = c - 'A' + 10;
7699 7698 else if ((c >= 'a') && (c <= 'f'))
7700 7699 c = c - 'a' + 10;
7701 7700 else
7702 7701 c = -1;
7703 7702 return (c);
7704 7703 }
7705 7704
7706 7705 /* Convert from Hex value in ASCII format to the equivalent bytes */
7707 7706 static boolean_t
7708 7707 stmf_base16_str_to_binary(char *c, int dplen, uint8_t *dp)
7709 7708 {
7710 7709 int ii;
7711 7710
7712 7711 for (ii = 0; ii < dplen; ii++) {
7713 7712 char nibble1, nibble2;
7714 7713 char enc_char = *c++;
7715 7714 nibble1 = stmf_ctoi(enc_char);
7716 7715
7717 7716 enc_char = *c++;
7718 7717 nibble2 = stmf_ctoi(enc_char);
7719 7718 if (nibble1 == -1 || nibble2 == -1)
7720 7719 return (B_FALSE);
7721 7720
7722 7721 dp[ii] = (nibble1 << 4) | nibble2;
7723 7722 }
7724 7723 return (B_TRUE);
7725 7724 }
7726 7725
7727 7726 boolean_t
7728 7727 stmf_scsilib_tptid_validate(scsi_transport_id_t *tptid, uint32_t total_sz,
7729 7728 uint16_t *tptid_sz)
7730 7729 {
7731 7730 uint16_t tpd_len = SCSI_TPTID_SIZE;
7732 7731
7733 7732 if (tptid_sz)
7734 7733 *tptid_sz = 0;
7735 7734 if (total_sz < sizeof (scsi_transport_id_t))
7736 7735 return (B_FALSE);
7737 7736
7738 7737 switch (tptid->protocol_id) {
7739 7738
7740 7739 case PROTOCOL_FIBRE_CHANNEL:
7741 7740 /* FC Transport ID validation checks. SPC3 rev23, Table 284 */
7742 7741 if (total_sz < tpd_len || tptid->format_code != 0)
7743 7742 return (B_FALSE);
7744 7743 break;
7745 7744
7746 7745 case PROTOCOL_iSCSI:
7747 7746 {
7748 7747 iscsi_transport_id_t *iscsiid;
7749 7748 uint16_t adn_len, name_len;
7750 7749
7751 7750 /* Check for valid format code, SPC3 rev 23 Table 288 */
7752 7751 if ((total_sz < tpd_len) ||
7753 7752 (tptid->format_code != 0 && tptid->format_code != 1))
7754 7753 return (B_FALSE);
7755 7754
7756 7755 iscsiid = (iscsi_transport_id_t *)tptid;
7757 7756 adn_len = READ_SCSI16(iscsiid->add_len, uint16_t);
7758 7757 tpd_len = sizeof (iscsi_transport_id_t) + adn_len - 1;
7759 7758
7760 7759 /*
7761 7760 * iSCSI Transport ID validation checks.
7762 7761 * As per SPC3 rev 23 Section 7.5.4.6 and Table 289 & Table 290
7763 7762 */
7764 7763 if (adn_len < 20 || (adn_len % 4 != 0))
7765 7764 return (B_FALSE);
7766 7765
7767 7766 name_len = strnlen(iscsiid->iscsi_name, adn_len);
7768 7767 if (name_len == 0 || name_len >= adn_len)
7769 7768 return (B_FALSE);
7770 7769
7771 7770 /* If the format_code is 1 check for ISID seperator */
7772 7771 if ((tptid->format_code == 1) && (strstr(iscsiid->iscsi_name,
7773 7772 SCSI_TPTID_ISCSI_ISID_SEPERATOR) == NULL))
7774 7773 return (B_FALSE);
7775 7774
7776 7775 }
7777 7776 break;
7778 7777
7779 7778 case PROTOCOL_SRP:
7780 7779 /* SRP Transport ID validation checks. SPC3 rev23, Table 287 */
7781 7780 if (total_sz < tpd_len || tptid->format_code != 0)
7782 7781 return (B_FALSE);
7783 7782 break;
7784 7783
7785 7784 case PROTOCOL_PARALLEL_SCSI:
7786 7785 case PROTOCOL_SSA:
7787 7786 case PROTOCOL_IEEE_1394:
7788 7787 case PROTOCOL_SAS:
7789 7788 case PROTOCOL_ADT:
7790 7789 case PROTOCOL_ATAPI:
7791 7790 default:
7792 7791 {
7793 7792 stmf_dflt_scsi_tptid_t *dflttpd;
7794 7793
7795 7794 tpd_len = sizeof (stmf_dflt_scsi_tptid_t);
7796 7795 if (total_sz < tpd_len)
7797 7796 return (B_FALSE);
7798 7797 dflttpd = (stmf_dflt_scsi_tptid_t *)tptid;
7799 7798 tpd_len = tpd_len + SCSI_READ16(&dflttpd->ident_len) - 1;
7800 7799 if (total_sz < tpd_len)
7801 7800 return (B_FALSE);
7802 7801 }
7803 7802 break;
7804 7803 }
7805 7804 if (tptid_sz)
7806 7805 *tptid_sz = tpd_len;
7807 7806 return (B_TRUE);
7808 7807 }
7809 7808
7810 7809 boolean_t
7811 7810 stmf_scsilib_tptid_compare(scsi_transport_id_t *tpd1,
7812 7811 scsi_transport_id_t *tpd2)
7813 7812 {
7814 7813 if ((tpd1->protocol_id != tpd2->protocol_id) ||
7815 7814 (tpd1->format_code != tpd2->format_code))
7816 7815 return (B_FALSE);
7817 7816
7818 7817 switch (tpd1->protocol_id) {
7819 7818
7820 7819 case PROTOCOL_iSCSI:
7821 7820 {
7822 7821 iscsi_transport_id_t *iscsitpd1, *iscsitpd2;
7823 7822 uint16_t len;
7824 7823
7825 7824 iscsitpd1 = (iscsi_transport_id_t *)tpd1;
7826 7825 iscsitpd2 = (iscsi_transport_id_t *)tpd2;
7827 7826 len = SCSI_READ16(&iscsitpd1->add_len);
7828 7827 if ((memcmp(iscsitpd1->add_len, iscsitpd2->add_len, 2) != 0) ||
7829 7828 (memcmp(iscsitpd1->iscsi_name, iscsitpd2->iscsi_name, len)
7830 7829 != 0))
7831 7830 return (B_FALSE);
7832 7831 }
7833 7832 break;
7834 7833
7835 7834 case PROTOCOL_SRP:
7836 7835 {
7837 7836 scsi_srp_transport_id_t *srptpd1, *srptpd2;
7838 7837
7839 7838 srptpd1 = (scsi_srp_transport_id_t *)tpd1;
7840 7839 srptpd2 = (scsi_srp_transport_id_t *)tpd2;
7841 7840 if (memcmp(srptpd1->srp_name, srptpd2->srp_name,
7842 7841 sizeof (srptpd1->srp_name)) != 0)
7843 7842 return (B_FALSE);
7844 7843 }
7845 7844 break;
7846 7845
7847 7846 case PROTOCOL_FIBRE_CHANNEL:
7848 7847 {
7849 7848 scsi_fc_transport_id_t *fctpd1, *fctpd2;
7850 7849
7851 7850 fctpd1 = (scsi_fc_transport_id_t *)tpd1;
7852 7851 fctpd2 = (scsi_fc_transport_id_t *)tpd2;
7853 7852 if (memcmp(fctpd1->port_name, fctpd2->port_name,
7854 7853 sizeof (fctpd1->port_name)) != 0)
7855 7854 return (B_FALSE);
7856 7855 }
7857 7856 break;
7858 7857
7859 7858 case PROTOCOL_PARALLEL_SCSI:
7860 7859 case PROTOCOL_SSA:
7861 7860 case PROTOCOL_IEEE_1394:
7862 7861 case PROTOCOL_SAS:
7863 7862 case PROTOCOL_ADT:
7864 7863 case PROTOCOL_ATAPI:
7865 7864 default:
7866 7865 {
7867 7866 stmf_dflt_scsi_tptid_t *dflt1, *dflt2;
7868 7867 uint16_t len;
7869 7868
7870 7869 dflt1 = (stmf_dflt_scsi_tptid_t *)tpd1;
7871 7870 dflt2 = (stmf_dflt_scsi_tptid_t *)tpd2;
7872 7871 len = SCSI_READ16(&dflt1->ident_len);
7873 7872 if ((memcmp(dflt1->ident_len, dflt2->ident_len, 2) != 0) ||
7874 7873 (memcmp(dflt1->ident, dflt2->ident, len) != 0))
7875 7874 return (B_FALSE);
7876 7875 }
7877 7876 break;
7878 7877 }
7879 7878 return (B_TRUE);
7880 7879 }
7881 7880
7882 7881 /*
7883 7882 * Changes devid_desc to corresponding TransportID format
7884 7883 * Returns :- pointer to stmf_remote_port_t
7885 7884 * Note :- Allocates continous memory for stmf_remote_port_t and TransportID,
7886 7885 * This memory need to be freed when this remote_port is no longer
7887 7886 * used.
7888 7887 */
7889 7888 stmf_remote_port_t *
7890 7889 stmf_scsilib_devid_to_remote_port(scsi_devid_desc_t *devid)
7891 7890 {
7892 7891 struct scsi_fc_transport_id *fc_tpd;
7893 7892 struct iscsi_transport_id *iscsi_tpd;
7894 7893 struct scsi_srp_transport_id *srp_tpd;
7895 7894 struct stmf_dflt_scsi_tptid *dflt_tpd;
7896 7895 uint16_t ident_len, sz = 0;
7897 7896 stmf_remote_port_t *rpt = NULL;
7898 7897
7899 7898 ident_len = devid->ident_length;
7900 7899 ASSERT(ident_len);
7901 7900 switch (devid->protocol_id) {
7902 7901 case PROTOCOL_FIBRE_CHANNEL:
7903 7902 sz = sizeof (scsi_fc_transport_id_t);
7904 7903 rpt = stmf_remote_port_alloc(sz);
7905 7904 rpt->rport_tptid->format_code = 0;
7906 7905 rpt->rport_tptid->protocol_id = devid->protocol_id;
7907 7906 fc_tpd = (scsi_fc_transport_id_t *)rpt->rport_tptid;
7908 7907 /*
7909 7908 * convert from "wwn.xxxxxxxxxxxxxxxx" to 8-byte binary
7910 7909 * skip first 4 byte for "wwn."
7911 7910 */
7912 7911 ASSERT(strncmp("wwn.", (char *)devid->ident, 4) == 0);
7913 7912 if ((ident_len < SCSI_TPTID_FC_PORT_NAME_SIZE * 2 + 4) ||
7914 7913 !stmf_base16_str_to_binary((char *)devid->ident + 4,
7915 7914 SCSI_TPTID_FC_PORT_NAME_SIZE, fc_tpd->port_name))
7916 7915 goto devid_to_remote_port_fail;
7917 7916 break;
7918 7917
7919 7918 case PROTOCOL_iSCSI:
7920 7919 sz = ALIGNED_TO_8BYTE_BOUNDARY(sizeof (iscsi_transport_id_t) +
7921 7920 ident_len - 1);
7922 7921 rpt = stmf_remote_port_alloc(sz);
7923 7922 rpt->rport_tptid->format_code = 0;
7924 7923 rpt->rport_tptid->protocol_id = devid->protocol_id;
7925 7924 iscsi_tpd = (iscsi_transport_id_t *)rpt->rport_tptid;
7926 7925 SCSI_WRITE16(iscsi_tpd->add_len, ident_len);
7927 7926 (void) memcpy(iscsi_tpd->iscsi_name, devid->ident, ident_len);
7928 7927 break;
7929 7928
7930 7929 case PROTOCOL_SRP:
7931 7930 sz = sizeof (scsi_srp_transport_id_t);
7932 7931 rpt = stmf_remote_port_alloc(sz);
7933 7932 rpt->rport_tptid->format_code = 0;
7934 7933 rpt->rport_tptid->protocol_id = devid->protocol_id;
7935 7934 srp_tpd = (scsi_srp_transport_id_t *)rpt->rport_tptid;
7936 7935 /*
7937 7936 * convert from "eui.xxxxxxxxxxxxxxx" to 8-byte binary
7938 7937 * skip first 4 byte for "eui."
7939 7938 * Assume 8-byte initiator-extension part of srp_name is NOT
7940 7939 * stored in devid and hence will be set as zero
7941 7940 */
7942 7941 ASSERT(strncmp("eui.", (char *)devid->ident, 4) == 0);
7943 7942 if ((ident_len < (SCSI_TPTID_SRP_PORT_NAME_LEN - 8) * 2 + 4) ||
7944 7943 !stmf_base16_str_to_binary((char *)devid->ident+4,
7945 7944 SCSI_TPTID_SRP_PORT_NAME_LEN, srp_tpd->srp_name))
7946 7945 goto devid_to_remote_port_fail;
7947 7946 break;
7948 7947
7949 7948 case PROTOCOL_PARALLEL_SCSI:
7950 7949 case PROTOCOL_SSA:
7951 7950 case PROTOCOL_IEEE_1394:
7952 7951 case PROTOCOL_SAS:
7953 7952 case PROTOCOL_ADT:
7954 7953 case PROTOCOL_ATAPI:
7955 7954 default :
7956 7955 ident_len = devid->ident_length;
7957 7956 sz = ALIGNED_TO_8BYTE_BOUNDARY(sizeof (stmf_dflt_scsi_tptid_t) +
7958 7957 ident_len - 1);
7959 7958 rpt = stmf_remote_port_alloc(sz);
7960 7959 rpt->rport_tptid->format_code = 0;
7961 7960 rpt->rport_tptid->protocol_id = devid->protocol_id;
7962 7961 dflt_tpd = (stmf_dflt_scsi_tptid_t *)rpt->rport_tptid;
7963 7962 SCSI_WRITE16(dflt_tpd->ident_len, ident_len);
7964 7963 (void) memcpy(dflt_tpd->ident, devid->ident, ident_len);
7965 7964 break;
7966 7965 }
7967 7966 return (rpt);
7968 7967
7969 7968 devid_to_remote_port_fail:
7970 7969 stmf_remote_port_free(rpt);
7971 7970 return (NULL);
7972 7971
7973 7972 }
7974 7973
7975 7974 stmf_remote_port_t *
7976 7975 stmf_remote_port_alloc(uint16_t tptid_sz) {
7977 7976 stmf_remote_port_t *rpt;
7978 7977 rpt = (stmf_remote_port_t *)kmem_zalloc(
7979 7978 sizeof (stmf_remote_port_t) + tptid_sz, KM_SLEEP);
7980 7979 rpt->rport_tptid_sz = tptid_sz;
7981 7980 rpt->rport_tptid = (scsi_transport_id_t *)(rpt + 1);
7982 7981 return (rpt);
7983 7982 }
7984 7983
7985 7984 void
7986 7985 stmf_remote_port_free(stmf_remote_port_t *rpt)
7987 7986 {
7988 7987 /*
7989 7988 * Note: stmf_scsilib_devid_to_remote_port() function allocates
7990 7989 * remote port structures for all transports in the same way, So
7991 7990 * it is safe to deallocate it in a protocol independent manner.
7992 7991 * If any of the allocation method changes, corresponding changes
7993 7992 * need to be made here too.
7994 7993 */
7995 7994 kmem_free(rpt, sizeof (stmf_remote_port_t) + rpt->rport_tptid_sz);
7996 7995 }
|
↓ open down ↓ |
1639 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX