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