1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
23  * Copyright 2011, 2015 Nexenta Systems, Inc. All rights reserved.
24  */
25 
26 #include <sys/cpuvar.h>
27 #include <sys/types.h>
28 #include <sys/conf.h>
29 #include <sys/file.h>
30 #include <sys/ddi.h>
31 #include <sys/sunddi.h>
32 #include <sys/modctl.h>
33 #include <sys/sysmacros.h>
34 #include <sys/sdt.h>
35 
36 #include <sys/socket.h>
37 #include <sys/strsubr.h>
38 
39 #include <sys/stmf.h>
40 #include <sys/stmf_ioctl.h>
41 #include <sys/portif.h>
42 #include <sys/idm/idm.h>
43 
44 #define	ISCSIT_TGT_SM_STRINGS
45 #include "iscsit.h"
46 #include "iscsit_isns.h"
47 
48 typedef struct {
49 	list_node_t		te_ctx_node;
50 	iscsit_tgt_event_t	te_ctx_event;
51 } tgt_event_ctx_t;
52 
53 static void
54 tgt_sm_event_dispatch(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx);
55 
56 static void
57 tgt_sm_created(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx);
58 
59 static void
60 tgt_sm_onlining(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx);
61 
62 static void
63 tgt_sm_online(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx);
64 
65 static void
66 tgt_sm_stmf_online(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx);
67 
68 static void
69 tgt_sm_deleting_need_offline(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx);
70 
71 static void
72 tgt_sm_offlining(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx);
73 
74 static void
75 tgt_sm_offline(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx);
76 
77 static void
78 tgt_sm_stmf_offline(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx);
79 
80 static void
81 tgt_sm_deleting_stmf_dereg(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx);
82 
83 static void
84 tgt_sm_deleting_stmf_dereg_fail(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx);
85 
86 static void
87 tgt_sm_deleting(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx);
88 
89 static void
90 iscsit_tgt_dereg_retry(void *arg);
91 
92 static void
93 iscsit_tgt_dereg_task(void *arg);
94 
95 static void
96 tgt_sm_new_state(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx,
97     iscsit_tgt_state_t new_state);
98 
99 
100 static iscsit_tgt_t *
101 iscsit_tgt_create(it_tgt_t *cfg_tgt);
102 
103 static void
104 iscsit_tgt_unref(void *tgt);
105 
106 static void
107 iscsit_tgt_async_wait_ref(iscsit_tgt_t *tgt, idm_refcnt_cb_t *cb_func);
108 
109 static void
110 iscsit_tgt_destroy(iscsit_tgt_t *tgt);
111 
112 static iscsit_tpgt_t *
113 iscsit_tgt_lookup_tpgt_locked(iscsit_tgt_t *tgt, uint16_t tag);
114 
115 static iscsit_tpg_t *
116 iscsit_tpg_lookup_locked(char *tpg_name);
117 
118 static iscsit_portal_t *
119 iscsit_tpg_portal_lookup_locked(iscsit_tpg_t *tpg,
120     struct sockaddr_storage *sa);
121 
122 static idm_status_t
123 iscsit_tgt_online(iscsit_tgt_t *tgt);
124 
125 static void
126 iscsit_tgt_offline(iscsit_tgt_t *tgt);
127 
128 static idm_status_t
129 iscsit_tgt_modify(iscsit_tgt_t *tgt, it_tgt_t *cfg_tgt);
130 
131 static idm_status_t
132 iscsit_tgt_merge_tpgt(iscsit_tgt_t *tgt, it_tgt_t *cfg_tgt,
133     list_t *tpgt_del_list);
134 
135 static iscsit_tpgt_t *
136 iscsit_tpgt_create(it_tpgt_t *cfg_tpgt);
137 
138 static iscsit_tpgt_t *
139 iscsit_tpgt_create_default();
140 
141 static void
142 iscsit_tpgt_destroy(iscsit_tpgt_t *tpgt);
143 
144 static iscsit_tpg_t *
145 iscsit_tpg_create(it_tpg_t *tpg);
146 
147 static void
148 iscsit_tpg_modify(iscsit_tpg_t *tpg, it_tpg_t *cfg_tpg);
149 
150 static void
151 iscsit_tpg_destroy(iscsit_tpg_t *tpg);
152 
153 static iscsit_portal_t *
154 iscsit_portal_create(iscsit_tpg_t *tpg, struct sockaddr_storage *sa);
155 
156 static void
157 iscsit_portal_delete(iscsit_portal_t *portal);
158 
159 static idm_status_t
160 iscsit_portal_online(iscsit_portal_t *portal);
161 
162 static void
163 iscsit_portal_offline(iscsit_portal_t *portal);
164 
165 
166 
167 /*
168  * Target state machine
169  */
170 
171 void
iscsit_tgt_sm_event(iscsit_tgt_t * tgt,iscsit_tgt_event_t event)172 iscsit_tgt_sm_event(iscsit_tgt_t *tgt, iscsit_tgt_event_t event)
173 {
174 	mutex_enter(&tgt->target_mutex);
175 	tgt_sm_event_locked(tgt, event);
176 	mutex_exit(&tgt->target_mutex);
177 }
178 
179 void
tgt_sm_event_locked(iscsit_tgt_t * tgt,iscsit_tgt_event_t event)180 tgt_sm_event_locked(iscsit_tgt_t *tgt, iscsit_tgt_event_t event)
181 {
182 	tgt_event_ctx_t *ctx;
183 
184 	iscsit_tgt_hold(tgt);
185 
186 	ctx = kmem_zalloc(sizeof (*ctx), KM_SLEEP);
187 
188 	ctx->te_ctx_event = event;
189 
190 	list_insert_tail(&tgt->target_events, ctx);
191 	/*
192 	 * Use the target_sm_busy flag to keep the state machine single
193 	 * threaded.  This also serves as recursion avoidance since this
194 	 * flag will always be set if we call iscsit_tgt_sm_event from
195 	 * within the state machine code.
196 	 */
197 	if (!tgt->target_sm_busy) {
198 		tgt->target_sm_busy = B_TRUE;
199 		while (!list_is_empty(&tgt->target_events)) {
200 			ctx = list_head(&tgt->target_events);
201 			list_remove(&tgt->target_events, ctx);
202 			idm_sm_audit_event(&tgt->target_state_audit,
203 			    SAS_ISCSIT_TGT, (int)tgt->target_state,
204 			    (int)ctx->te_ctx_event, 0);
205 			mutex_exit(&tgt->target_mutex);
206 			tgt_sm_event_dispatch(tgt, ctx);
207 			mutex_enter(&tgt->target_mutex);
208 		}
209 		tgt->target_sm_busy = B_FALSE;
210 
211 	}
212 
213 	iscsit_tgt_rele(tgt);
214 }
215 
216 static void
tgt_sm_event_dispatch(iscsit_tgt_t * tgt,tgt_event_ctx_t * ctx)217 tgt_sm_event_dispatch(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx)
218 {
219 	DTRACE_PROBE2(tgt__event, iscsit_tgt_t *, tgt,
220 	    tgt_event_ctx_t *, ctx);
221 
222 	IDM_SM_LOG(CE_NOTE, "tgt_sm_event_dispatch: tgt %p event %s(%d)",
223 	    (void *)tgt, iscsit_te_name[ctx->te_ctx_event], ctx->te_ctx_event);
224 
225 	/* State independent actions */
226 	switch (ctx->te_ctx_event) {
227 	case TE_DELETE:
228 		tgt->target_deleting = B_TRUE;
229 		break;
230 	}
231 
232 	/* State dependent actions */
233 	switch (tgt->target_state) {
234 	case TS_CREATED:
235 		tgt_sm_created(tgt, ctx);
236 		break;
237 	case TS_ONLINING:
238 		tgt_sm_onlining(tgt, ctx);
239 		break;
240 	case TS_ONLINE:
241 		tgt_sm_online(tgt, ctx);
242 		break;
243 	case TS_STMF_ONLINE:
244 		tgt_sm_stmf_online(tgt, ctx);
245 		break;
246 	case TS_DELETING_NEED_OFFLINE:
247 		tgt_sm_deleting_need_offline(tgt, ctx);
248 		break;
249 	case TS_OFFLINING:
250 		tgt_sm_offlining(tgt, ctx);
251 		break;
252 	case TS_OFFLINE:
253 		tgt_sm_offline(tgt, ctx);
254 		break;
255 	case TS_STMF_OFFLINE:
256 		tgt_sm_stmf_offline(tgt, ctx);
257 		break;
258 	case TS_DELETING_STMF_DEREG:
259 		tgt_sm_deleting_stmf_dereg(tgt, ctx);
260 		break;
261 	case TS_DELETING_STMF_DEREG_FAIL:
262 		tgt_sm_deleting_stmf_dereg_fail(tgt, ctx);
263 		break;
264 	case TS_DELETING:
265 		tgt_sm_deleting(tgt, ctx);
266 		break;
267 	default:
268 		ASSERT(0);
269 	}
270 
271 	kmem_free(ctx, sizeof (*ctx));
272 }
273 
274 static void
tgt_sm_created(iscsit_tgt_t * tgt,tgt_event_ctx_t * ctx)275 tgt_sm_created(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx)
276 {
277 	stmf_change_status_t	scs;
278 
279 	switch (ctx->te_ctx_event) {
280 	case TE_STMF_ONLINE_REQ:
281 		tgt_sm_new_state(tgt, ctx, TS_ONLINING);
282 		break;
283 	case TE_DELETE:
284 		tgt_sm_new_state(tgt, ctx, TS_DELETING_STMF_DEREG);
285 		break;
286 	case TE_STMF_OFFLINE_REQ:
287 		/*
288 		 * We're already offline but update to an equivelant
289 		 * state just to note that STMF talked to us.
290 		 */
291 		scs.st_completion_status = STMF_SUCCESS;
292 		scs.st_additional_info = NULL;
293 		tgt_sm_new_state(tgt, ctx, TS_OFFLINE);
294 		(void) stmf_ctl(STMF_CMD_LPORT_OFFLINE_COMPLETE,
295 		    tgt->target_stmf_lport, &scs);
296 		break;
297 	case TE_STMF_ONLINE_COMPLETE_ACK:
298 	case TE_STMF_OFFLINE_COMPLETE_ACK:
299 		/* Ignore */
300 		break;
301 	default:
302 		ASSERT(0);
303 	}
304 }
305 
306 static void
tgt_sm_onlining(iscsit_tgt_t * tgt,tgt_event_ctx_t * ctx)307 tgt_sm_onlining(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx)
308 {
309 	stmf_change_status_t	scs;
310 
311 	switch (ctx->te_ctx_event) {
312 	case TE_ONLINE_SUCCESS:
313 		tgt_sm_new_state(tgt, ctx, TS_ONLINE);
314 		break;
315 	case TE_ONLINE_FAIL:
316 		tgt_sm_new_state(tgt, ctx, TS_STMF_OFFLINE);
317 		break;
318 	case TE_DELETE:
319 		/* TE_DELETE is handled in tgt_sm_event_dispatch() */
320 		break;
321 	case TE_STMF_ONLINE_REQ:
322 	case TE_STMF_OFFLINE_REQ:
323 		/*
324 		 * We can't complete STMF's request since we are busy going
325 		 * online.
326 		 */
327 		scs.st_completion_status = STMF_INVALID_ARG;
328 		scs.st_additional_info = NULL;
329 		(void) stmf_ctl((ctx->te_ctx_event == TE_STMF_ONLINE_REQ) ?
330 		    STMF_CMD_LPORT_ONLINE_COMPLETE :
331 		    STMF_CMD_LPORT_OFFLINE_COMPLETE,
332 		    tgt->target_stmf_lport, &scs);
333 		break;
334 	case TE_STMF_ONLINE_COMPLETE_ACK:
335 	case TE_STMF_OFFLINE_COMPLETE_ACK:
336 		/* Ignore */
337 		break;
338 	default:
339 		ASSERT(0);
340 	}
341 }
342 
343 static void
tgt_sm_online(iscsit_tgt_t * tgt,tgt_event_ctx_t * ctx)344 tgt_sm_online(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx)
345 {
346 	stmf_change_status_t	scs;
347 
348 	switch (ctx->te_ctx_event) {
349 	case TE_STMF_ONLINE_COMPLETE_ACK:
350 		if (tgt->target_deleting) {
351 			tgt_sm_new_state(tgt, ctx, TS_DELETING_NEED_OFFLINE);
352 		} else {
353 			tgt_sm_new_state(tgt, ctx, TS_STMF_ONLINE);
354 		}
355 		break;
356 	case TE_DELETE:
357 		/* TE_DELETE is handled in tgt_sm_event_dispatch() */
358 		break;
359 	case TE_STMF_ONLINE_REQ:
360 	case TE_STMF_OFFLINE_REQ:
361 		/*
362 		 * We can't complete STMF's request since we are busy going
363 		 * online (waiting for acknowlegement from STMF)
364 		 */
365 		scs.st_completion_status = STMF_INVALID_ARG;
366 		scs.st_additional_info = NULL;
367 		(void) stmf_ctl((ctx->te_ctx_event == TE_STMF_ONLINE_REQ) ?
368 		    STMF_CMD_LPORT_ONLINE_COMPLETE :
369 		    STMF_CMD_LPORT_OFFLINE_COMPLETE,
370 		    tgt->target_stmf_lport, &scs);
371 		break;
372 	case TE_STMF_OFFLINE_COMPLETE_ACK:
373 		/* Ignore */
374 		break;
375 	default:
376 		ASSERT(0);
377 	}
378 }
379 
380 
381 static void
tgt_sm_stmf_online(iscsit_tgt_t * tgt,tgt_event_ctx_t * ctx)382 tgt_sm_stmf_online(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx)
383 {
384 	stmf_change_status_t	scs;
385 
386 	/* Deregister target with iSNS whenever we leave this state */
387 
388 	switch (ctx->te_ctx_event) {
389 	case TE_DELETE:
390 		(void) iscsit_isns_deregister(tgt);
391 		tgt_sm_new_state(tgt, ctx, TS_DELETING_NEED_OFFLINE);
392 		break;
393 	case TE_STMF_OFFLINE_REQ:
394 		(void) iscsit_isns_deregister(tgt);
395 		tgt_sm_new_state(tgt, ctx, TS_OFFLINING);
396 		break;
397 	case TE_STMF_ONLINE_REQ:
398 		/* Already online */
399 		scs.st_completion_status = STMF_ALREADY;
400 		scs.st_additional_info = NULL;
401 		(void) stmf_ctl(STMF_CMD_LPORT_ONLINE_COMPLETE,
402 		    tgt->target_stmf_lport, &scs);
403 		break;
404 	case TE_STMF_ONLINE_COMPLETE_ACK:
405 	case TE_STMF_OFFLINE_COMPLETE_ACK:
406 		/* Ignore */
407 		break;
408 	default:
409 		ASSERT(0);
410 	}
411 }
412 
413 
414 static void
tgt_sm_deleting_need_offline(iscsit_tgt_t * tgt,tgt_event_ctx_t * ctx)415 tgt_sm_deleting_need_offline(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx)
416 {
417 	stmf_change_status_t	scs;
418 
419 	switch (ctx->te_ctx_event) {
420 	case TE_STMF_OFFLINE_REQ:
421 		tgt_sm_new_state(tgt, ctx, TS_OFFLINING);
422 		break;
423 	case TE_DELETE:
424 		/* TE_DELETE is handled in tgt_sm_event_dispatch() */
425 		break;
426 	case TE_STMF_ONLINE_REQ:
427 		/*
428 		 * We can't complete STMF's request since we need to be offlined
429 		 */
430 		scs.st_completion_status = STMF_INVALID_ARG;
431 		scs.st_additional_info = NULL;
432 		(void) stmf_ctl(STMF_CMD_LPORT_ONLINE_COMPLETE,
433 		    tgt->target_stmf_lport, &scs);
434 		break;
435 	case TE_STMF_ONLINE_COMPLETE_ACK:
436 	case TE_STMF_OFFLINE_COMPLETE_ACK:
437 		/* Ignore */
438 		break;
439 	default:
440 		ASSERT(0);
441 	}
442 }
443 
444 
445 static void
tgt_sm_offlining(iscsit_tgt_t * tgt,tgt_event_ctx_t * ctx)446 tgt_sm_offlining(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx)
447 {
448 	stmf_change_status_t	scs;
449 
450 	switch (ctx->te_ctx_event) {
451 	case TE_OFFLINE_COMPLETE:
452 		tgt_sm_new_state(tgt, ctx, TS_OFFLINE);
453 		break;
454 	case TE_DELETE:
455 		/* TE_DELETE is handled in tgt_sm_event_dispatch() */
456 		break;
457 	case TE_STMF_ONLINE_REQ:
458 	case TE_STMF_OFFLINE_REQ:
459 		/*
460 		 * We can't complete STMF's request since we are busy going
461 		 * offline.
462 		 */
463 		scs.st_completion_status = STMF_INVALID_ARG;
464 		scs.st_additional_info = NULL;
465 		(void) stmf_ctl((ctx->te_ctx_event == TE_STMF_ONLINE_REQ) ?
466 		    STMF_CMD_LPORT_ONLINE_COMPLETE :
467 		    STMF_CMD_LPORT_OFFLINE_COMPLETE,
468 		    tgt->target_stmf_lport, &scs);
469 		break;
470 	case TE_STMF_ONLINE_COMPLETE_ACK:
471 	case TE_STMF_OFFLINE_COMPLETE_ACK:
472 		/* Ignore */
473 		break;
474 	default:
475 		ASSERT(0);
476 	}
477 }
478 
479 
480 static void
tgt_sm_offline(iscsit_tgt_t * tgt,tgt_event_ctx_t * ctx)481 tgt_sm_offline(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx)
482 {
483 	stmf_change_status_t	scs;
484 
485 	switch (ctx->te_ctx_event) {
486 	case TE_STMF_OFFLINE_COMPLETE_ACK:
487 		if (tgt->target_deleting) {
488 			tgt_sm_new_state(tgt, ctx, TS_DELETING_STMF_DEREG);
489 		} else {
490 			tgt_sm_new_state(tgt, ctx, TS_STMF_OFFLINE);
491 		}
492 		break;
493 	case TE_DELETE:
494 		/* TE_DELETE is handled in tgt_sm_event_dispatch() */
495 		break;
496 	case TE_STMF_ONLINE_REQ:
497 	case TE_STMF_OFFLINE_REQ:
498 		/*
499 		 * We can't complete STMF's request since we are busy going
500 		 * offline.
501 		 */
502 		scs.st_completion_status = STMF_INVALID_ARG;
503 		scs.st_additional_info = NULL;
504 		(void) stmf_ctl((ctx->te_ctx_event == TE_STMF_ONLINE_REQ) ?
505 		    STMF_CMD_LPORT_ONLINE_COMPLETE :
506 		    STMF_CMD_LPORT_OFFLINE_COMPLETE,
507 		    tgt->target_stmf_lport, &scs);
508 		break;
509 	case TE_STMF_ONLINE_COMPLETE_ACK:
510 		/* Ignore */
511 		break;
512 	default:
513 		ASSERT(0);
514 	}
515 }
516 
517 
518 static void
tgt_sm_stmf_offline(iscsit_tgt_t * tgt,tgt_event_ctx_t * ctx)519 tgt_sm_stmf_offline(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx)
520 {
521 	stmf_change_status_t	scs;
522 
523 	switch (ctx->te_ctx_event) {
524 	case TE_STMF_ONLINE_REQ:
525 		tgt_sm_new_state(tgt, ctx, TS_ONLINING);
526 		break;
527 	case TE_DELETE:
528 		tgt_sm_new_state(tgt, ctx, TS_DELETING_STMF_DEREG);
529 		break;
530 	case TE_STMF_OFFLINE_REQ:
531 		/* Already offline */
532 		scs.st_completion_status = STMF_ALREADY;
533 		scs.st_additional_info = NULL;
534 		(void) stmf_ctl(STMF_CMD_LPORT_OFFLINE_COMPLETE,
535 		    tgt->target_stmf_lport, &scs);
536 		break;
537 	case TE_STMF_ONLINE_COMPLETE_ACK:
538 	case TE_STMF_OFFLINE_COMPLETE_ACK:
539 		/* Ignore */
540 		break;
541 	default:
542 		ASSERT(0);
543 	}
544 }
545 
546 
547 static void
tgt_sm_deleting_stmf_dereg(iscsit_tgt_t * tgt,tgt_event_ctx_t * ctx)548 tgt_sm_deleting_stmf_dereg(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx)
549 {
550 	stmf_change_status_t	scs;
551 
552 	/* Terminal state, no events */
553 	switch (ctx->te_ctx_event) {
554 	case TE_STMF_ONLINE_REQ:
555 	case TE_STMF_OFFLINE_REQ:
556 		/*
557 		 * We can't complete STMF's request since we are being deleted
558 		 */
559 		scs.st_completion_status = STMF_INVALID_ARG;
560 		scs.st_additional_info = NULL;
561 		(void) stmf_ctl((ctx->te_ctx_event == TE_STMF_ONLINE_REQ) ?
562 		    STMF_CMD_LPORT_ONLINE_COMPLETE :
563 		    STMF_CMD_LPORT_OFFLINE_COMPLETE,
564 		    tgt->target_stmf_lport, &scs);
565 		break;
566 	case TE_STMF_ONLINE_COMPLETE_ACK:
567 	case TE_STMF_OFFLINE_COMPLETE_ACK:
568 		/* Ignore */
569 		break;
570 	case TE_STMF_DEREG_SUCCESS:
571 		tgt_sm_new_state(tgt, ctx, TS_DELETING);
572 		break;
573 	case TE_STMF_DEREG_FAIL:
574 		tgt_sm_new_state(tgt, ctx, TS_DELETING_STMF_DEREG_FAIL);
575 		break;
576 	default:
577 		ASSERT(0);
578 	}
579 }
580 
581 static void
tgt_sm_deleting_stmf_dereg_fail(iscsit_tgt_t * tgt,tgt_event_ctx_t * ctx)582 tgt_sm_deleting_stmf_dereg_fail(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx)
583 {
584 	stmf_change_status_t	scs;
585 
586 	/* Terminal state, no events */
587 	switch (ctx->te_ctx_event) {
588 	case TE_STMF_ONLINE_REQ:
589 	case TE_STMF_OFFLINE_REQ:
590 		/*
591 		 * We can't complete STMF's request since we are being deleted
592 		 */
593 		scs.st_completion_status = STMF_INVALID_ARG;
594 		scs.st_additional_info = NULL;
595 		(void) stmf_ctl((ctx->te_ctx_event == TE_STMF_ONLINE_REQ) ?
596 		    STMF_CMD_LPORT_ONLINE_COMPLETE :
597 		    STMF_CMD_LPORT_OFFLINE_COMPLETE,
598 		    tgt->target_stmf_lport, &scs);
599 		break;
600 	case TE_STMF_ONLINE_COMPLETE_ACK:
601 	case TE_STMF_OFFLINE_COMPLETE_ACK:
602 		/* Ignore */
603 		break;
604 	case TE_STMF_DEREG_RETRY:
605 		tgt_sm_new_state(tgt, ctx, TS_DELETING_STMF_DEREG);
606 		break;
607 	default:
608 		ASSERT(0);
609 	}
610 }
611 
612 static void
tgt_sm_deleting(iscsit_tgt_t * tgt,tgt_event_ctx_t * ctx)613 tgt_sm_deleting(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx)
614 {
615 	stmf_change_status_t	scs;
616 
617 	/* Terminal state, no events */
618 	switch (ctx->te_ctx_event) {
619 	case TE_STMF_ONLINE_REQ:
620 	case TE_STMF_OFFLINE_REQ:
621 		/*
622 		 * We can't complete STMF's request since we are being deleted
623 		 */
624 		scs.st_completion_status = STMF_INVALID_ARG;
625 		scs.st_additional_info = NULL;
626 		(void) stmf_ctl((ctx->te_ctx_event == TE_STMF_ONLINE_REQ) ?
627 		    STMF_CMD_LPORT_ONLINE_COMPLETE :
628 		    STMF_CMD_LPORT_OFFLINE_COMPLETE,
629 		    tgt->target_stmf_lport, &scs);
630 		break;
631 	case TE_STMF_ONLINE_COMPLETE_ACK:
632 	case TE_STMF_OFFLINE_COMPLETE_ACK:
633 		/* Ignore */
634 		break;
635 	default:
636 		ASSERT(0);
637 	}
638 }
639 
640 
641 static void
iscsit_tgt_dereg_retry(void * arg)642 iscsit_tgt_dereg_retry(void *arg)
643 {
644 	iscsit_tgt_t *tgt = arg;
645 
646 	/*
647 	 * Rather than guaranteeing the target state machine code will not
648 	 * block for long periods of time (tying up this callout thread)
649 	 * we will queue a task on the taskq to send the retry event.
650 	 * If it fails we'll setup another timeout and try again later.
651 	 */
652 	if (taskq_dispatch(iscsit_global.global_dispatch_taskq,
653 	    iscsit_tgt_dereg_task, tgt, DDI_NOSLEEP) == TASKQID_INVALID) {
654 		/* Dispatch failed, try again later */
655 		(void) timeout(iscsit_tgt_dereg_retry, tgt,
656 		    drv_usectohz(TGT_DEREG_RETRY_SECONDS * 1000000));
657 	}
658 }
659 
660 static void
iscsit_tgt_dereg_task(void * arg)661 iscsit_tgt_dereg_task(void *arg)
662 {
663 	iscsit_tgt_t *tgt = arg;
664 
665 	iscsit_tgt_sm_event(tgt, TE_STMF_DEREG_RETRY);
666 }
667 
668 static void
tgt_sm_new_state(iscsit_tgt_t * tgt,tgt_event_ctx_t * ctx,iscsit_tgt_state_t new_state)669 tgt_sm_new_state(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx,
670     iscsit_tgt_state_t new_state)
671 {
672 	stmf_local_port_t		*lport = tgt->target_stmf_lport;
673 	stmf_change_status_t		scs;
674 	stmf_state_change_info_t	sci;
675 	idm_status_t			idmrc;
676 	stmf_status_t			stmfrc;
677 
678 	scs.st_completion_status = STMF_SUCCESS;
679 	scs.st_additional_info = NULL;
680 
681 	/*
682 	 * Validate new state
683 	 */
684 	ASSERT(new_state != TS_UNDEFINED);
685 	ASSERT3U(new_state, <, TS_MAX_STATE);
686 
687 	new_state = (new_state < TS_MAX_STATE) ?
688 	    new_state : TS_UNDEFINED;
689 
690 	IDM_SM_LOG(CE_NOTE, "tgt_sm_new_state: tgt %p, %s(%d) --> %s(%d)\n",
691 	    (void *) tgt, iscsit_ts_name[tgt->target_state], tgt->target_state,
692 	    iscsit_ts_name[new_state], new_state);
693 	DTRACE_PROBE3(target__state__change,
694 	    iscsit_tgt_t *, tgt, tgt_event_ctx_t *, ctx,
695 	    iscsit_tgt_state_t, new_state);
696 
697 	mutex_enter(&tgt->target_mutex);
698 	idm_sm_audit_state_change(&tgt->target_state_audit, SAS_ISCSIT_TGT,
699 	    (int)tgt->target_state, (int)new_state);
700 	tgt->target_last_state = tgt->target_state;
701 	tgt->target_state = new_state;
702 	mutex_exit(&tgt->target_mutex);
703 
704 	switch (tgt->target_state) {
705 	case TS_ONLINING:
706 		idmrc = iscsit_tgt_online(tgt);
707 		if (idmrc != IDM_STATUS_SUCCESS) {
708 			scs.st_completion_status = STMF_TARGET_FAILURE;
709 			iscsit_tgt_sm_event(tgt, TE_ONLINE_FAIL);
710 		} else {
711 			iscsit_tgt_sm_event(tgt, TE_ONLINE_SUCCESS);
712 		}
713 		/*
714 		 * Let STMF know the how the online operation completed.
715 		 * STMF will respond with an acknowlege later
716 		 */
717 		(void) stmf_ctl(STMF_CMD_LPORT_ONLINE_COMPLETE, lport, &scs);
718 		break;
719 	case TS_ONLINE:
720 		break;
721 	case TS_STMF_ONLINE:
722 		(void) iscsit_isns_register(tgt);
723 		break;
724 	case TS_DELETING_NEED_OFFLINE:
725 		sci.st_rflags = STMF_RFLAG_STAY_OFFLINED;
726 		sci.st_additional_info = "Offline for delete";
727 		(void) stmf_ctl(STMF_CMD_LPORT_OFFLINE, lport, &sci);
728 		break;
729 	case TS_OFFLINING:
730 		/* Async callback generates completion event */
731 		iscsit_tgt_offline(tgt);
732 		break;
733 	case TS_OFFLINE:
734 		break;
735 	case TS_STMF_OFFLINE:
736 		break;
737 	case TS_DELETING_STMF_DEREG:
738 		stmfrc = stmf_deregister_local_port(tgt->target_stmf_lport);
739 		if (stmfrc == STMF_SUCCESS) {
740 			iscsit_tgt_sm_event(tgt, TE_STMF_DEREG_SUCCESS);
741 		} else {
742 			iscsit_tgt_sm_event(tgt, TE_STMF_DEREG_FAIL);
743 		}
744 		break;
745 	case TS_DELETING_STMF_DEREG_FAIL:
746 		/* Retry dereg in 1 second */
747 		(void) timeout(iscsit_tgt_dereg_retry, tgt,
748 		    drv_usectohz(TGT_DEREG_RETRY_SECONDS * 1000000));
749 		break;
750 	case TS_DELETING:
751 		iscsit_tgt_async_wait_ref(tgt, iscsit_tgt_unref);
752 		break;
753 	default:
754 		ASSERT(0);
755 	}
756 }
757 
758 
759 /*
760  * Target, TPGT, TPG utility functions
761  */
762 
763 it_cfg_status_t
iscsit_config_merge_tgt(it_config_t * cfg)764 iscsit_config_merge_tgt(it_config_t *cfg)
765 {
766 	it_tgt_t	*cfg_tgt;
767 	iscsit_tgt_t	*tgt, *next_tgt;
768 	it_cfg_status_t	itrc = ITCFG_SUCCESS;
769 
770 
771 	/*
772 	 * 1. >> Lock <<
773 	 * 2. Removing deleted objects
774 	 * 3. Add deleted targets to global delete list
775 	 * 4. "delete" event to target state machine
776 	 * 5. >> Unlock <<
777 	 * 6. Create new targets, update modified targets
778 	 */
779 	for (tgt = avl_first(&iscsit_global.global_target_list);
780 	    tgt != NULL;
781 	    tgt = next_tgt) {
782 		next_tgt = AVL_NEXT(&iscsit_global.global_target_list, tgt);
783 
784 		if (it_tgt_lookup(cfg, tgt->target_name) == NULL) {
785 			avl_remove(&iscsit_global.global_target_list, tgt);
786 			list_insert_tail(
787 			    &iscsit_global.global_deleted_target_list, tgt);
788 			iscsit_tgt_sm_event(tgt, TE_DELETE);
789 		}
790 	}
791 
792 	/* Now walk through the list of configured targets */
793 	for (cfg_tgt = cfg->config_tgt_list;
794 	    cfg_tgt != NULL;
795 	    cfg_tgt = cfg_tgt->tgt_next) {
796 		/* See if we have an existing target */
797 		tgt = iscsit_tgt_lookup_locked(cfg_tgt->tgt_name);
798 
799 		if (tgt == NULL) {
800 			tgt = iscsit_tgt_create(cfg_tgt);
801 			if (tgt == NULL)
802 				return (ITCFG_TGT_CREATE_ERR);
803 			avl_add(&iscsit_global.global_target_list, tgt);
804 		} else {
805 			if (iscsit_tgt_modify(tgt, cfg_tgt) !=
806 			    IDM_STATUS_SUCCESS)
807 				itrc = ITCFG_MISC_ERR;
808 			iscsit_tgt_rele(tgt);
809 		}
810 	}
811 
812 	/*
813 	 * Targets on the iscsit_global.global_deleted_target_list will remove
814 	 * and destroy themselves when their associated state machines reach
815 	 * the TS_DELETED state and all references are released.
816 	 */
817 	return (itrc);
818 }
819 
820 iscsit_tgt_t *
iscsit_tgt_lookup(char * target_name)821 iscsit_tgt_lookup(char *target_name)
822 {
823 	iscsit_tgt_t	*result;
824 
825 	ISCSIT_GLOBAL_LOCK(RW_READER);
826 	result = iscsit_tgt_lookup_locked(target_name);
827 	ISCSIT_GLOBAL_UNLOCK();
828 
829 	return (result);
830 }
831 
832 iscsit_tgt_t *
iscsit_tgt_lookup_locked(char * target_name)833 iscsit_tgt_lookup_locked(char *target_name)
834 {
835 	iscsit_tgt_t	tmp_tgt;
836 	iscsit_tgt_t	*result;
837 
838 	/*
839 	 * Use a dummy target for lookup, filling in all fields used in AVL
840 	 * comparison.
841 	 */
842 	tmp_tgt.target_name = target_name;
843 	if ((result = avl_find(&iscsit_global.global_target_list,
844 	    &tmp_tgt, NULL)) != NULL) {
845 		iscsit_tgt_hold(result);
846 	}
847 
848 	return (result);
849 }
850 
851 iscsit_tgt_t *
iscsit_tgt_create(it_tgt_t * cfg_tgt)852 iscsit_tgt_create(it_tgt_t *cfg_tgt)
853 {
854 	iscsit_tgt_t		*result;
855 	stmf_local_port_t	*lport;
856 	char			*alias;
857 
858 	/*
859 	 * Each target is an STMF local port.
860 	 */
861 	lport = stmf_alloc(STMF_STRUCT_STMF_LOCAL_PORT,
862 	    sizeof (iscsit_tgt_t) + sizeof (scsi_devid_desc_t) +
863 	    strnlen(cfg_tgt->tgt_name, MAX_ISCSI_NODENAMELEN) + 1, 0);
864 	if (lport == NULL) {
865 		return (NULL);
866 	}
867 
868 	result = lport->lport_port_private;
869 	result->target_state = TS_CREATED;
870 	result->target_stmf_lport_registered = 0;
871 	/* Use pointer arithmetic to find scsi_devid_desc_t */
872 	result->target_devid = (scsi_devid_desc_t *)(result + 1);
873 	(void) strcpy((char *)result->target_devid->ident, cfg_tgt->tgt_name);
874 	result->target_devid->ident_length =
875 	    strnlen(cfg_tgt->tgt_name, MAX_ISCSI_NODENAMELEN);
876 	result->target_devid->protocol_id = PROTOCOL_iSCSI;
877 	result->target_devid->piv = 1;
878 	result->target_devid->code_set = CODE_SET_ASCII;
879 	result->target_devid->association = ID_IS_TARGET_PORT;
880 
881 	/* Store a shortcut to the target name */
882 	result->target_name = (char *)result->target_devid->ident;
883 	idm_sm_audit_init(&result->target_state_audit);
884 	mutex_init(&result->target_mutex, NULL, MUTEX_DEFAULT, NULL);
885 	avl_create(&result->target_sess_list, iscsit_sess_avl_compare,
886 	    sizeof (iscsit_sess_t), offsetof(iscsit_sess_t, ist_tgt_ln));
887 	avl_create(&result->target_tpgt_list, iscsit_tpgt_avl_compare,
888 	    sizeof (iscsit_tpgt_t), offsetof(iscsit_tpgt_t, tpgt_tgt_ln));
889 	list_create(&result->target_events, sizeof (tgt_event_ctx_t),
890 	    offsetof(tgt_event_ctx_t, te_ctx_node));
891 	idm_refcnt_init(&result->target_refcnt, result);
892 	idm_refcnt_init(&result->target_sess_refcnt, result);
893 
894 	/* Set target alias */
895 	if (nvlist_lookup_string(cfg_tgt->tgt_properties, "alias", &alias) == 0)
896 		lport->lport_alias = strdup(alias);
897 
898 	/* Finish initializing local port */
899 	/*
900 	 * Would like infinite timeout, but this is about as long as can
901 	 * be specified to stmf on a 32 bit kernel.
902 	 */
903 	lport->lport_abort_timeout = 2000; /* seconds */
904 	lport->lport_id = result->target_devid;
905 	lport->lport_pp = iscsit_global.global_pp;
906 	lport->lport_ds = iscsit_global.global_dbuf_store;
907 	lport->lport_xfer_data = &iscsit_xfer_scsi_data;
908 	lport->lport_send_status = &iscsit_send_scsi_status;
909 	lport->lport_task_free = &iscsit_lport_task_free;
910 	lport->lport_abort = &iscsit_abort;
911 	lport->lport_ctl = &iscsit_ctl;
912 	result->target_stmf_lport = lport;
913 
914 	/*
915 	 * We need a global hold until the STMF-ONLINE state machine
916 	 * completes.  Acquire that hold now, in case we need to call
917 	 * iscsit_tgt_destroy, which will also release the hold.
918 	 */
919 	iscsit_global_hold();
920 
921 	/*
922 	 * Additional target modifications from config
923 	 */
924 	if (iscsit_tgt_modify(result, cfg_tgt) != IDM_STATUS_SUCCESS) {
925 		iscsit_tgt_destroy(result);
926 		return (NULL);
927 	}
928 
929 	/*
930 	 * Register the target with STMF but not until we have all the
931 	 * TPGT bindings and any other additional config setup.  STMF
932 	 * may immediately ask us to go online.
933 	 */
934 	if (stmf_register_local_port(lport) != STMF_SUCCESS) {
935 		iscsit_tgt_destroy(result);
936 		return (NULL);
937 	}
938 	result->target_stmf_lport_registered = 1;
939 
940 	return (result);
941 }
942 
943 static idm_status_t
iscsit_tgt_modify(iscsit_tgt_t * tgt,it_tgt_t * cfg_tgt)944 iscsit_tgt_modify(iscsit_tgt_t *tgt, it_tgt_t *cfg_tgt)
945 {
946 	idm_status_t	idmrc = IDM_STATUS_SUCCESS;
947 	list_t		tpgt_del_list;
948 	char		*alias;
949 
950 	/* Merge TPGT */
951 	list_create(&tpgt_del_list, sizeof (iscsit_tpgt_t),
952 	    offsetof(iscsit_tpgt_t, tpgt_delete_ln));
953 
954 	mutex_enter(&tgt->target_mutex);
955 	if (tgt->target_props) {
956 		nvlist_free(tgt->target_props);
957 		tgt->target_props = NULL;
958 	}
959 	(void) nvlist_dup(cfg_tgt->tgt_properties, &tgt->target_props,
960 	    KM_SLEEP);
961 
962 	/* Update alias */
963 	if (tgt->target_stmf_lport->lport_alias) {
964 		strfree(tgt->target_stmf_lport->lport_alias);
965 		tgt->target_stmf_lport->lport_alias = NULL;
966 	}
967 	if (nvlist_lookup_string(tgt->target_props, "alias", &alias) == 0)
968 		tgt->target_stmf_lport->lport_alias = strdup(alias);
969 
970 	if ((idmrc = iscsit_tgt_merge_tpgt(tgt, cfg_tgt, &tpgt_del_list)) !=
971 	    IDM_STATUS_SUCCESS) {
972 		/* This should never happen */
973 		cmn_err(CE_WARN, "Fail to configure TPGTs for "
974 		    "target %s, the target modification could not be "
975 		    "completed.", tgt->target_name);
976 	}
977 
978 	mutex_exit(&tgt->target_mutex);
979 
980 	iscsit_config_destroy_tpgts(&tpgt_del_list);
981 
982 	/*
983 	 * If the target is truly modified (not newly created),
984 	 * inform iSNS to update the target registration.
985 	 */
986 	if ((tgt->target_generation > 0) &&
987 	    (cfg_tgt->tgt_generation > tgt->target_generation)) {
988 		iscsit_isns_target_update(tgt);
989 	}
990 
991 	tgt->target_generation = cfg_tgt->tgt_generation;
992 
993 	return (idmrc);
994 }
995 
996 void
iscsit_config_destroy_tpgts(list_t * tpgt_del_list)997 iscsit_config_destroy_tpgts(list_t *tpgt_del_list)
998 {
999 	iscsit_tpgt_t	*tpgt, *next_tpgt;
1000 
1001 	for (tpgt = list_head(tpgt_del_list);
1002 	    tpgt != NULL;
1003 	    tpgt = next_tpgt) {
1004 		next_tpgt = list_next(tpgt_del_list, tpgt);
1005 
1006 		list_remove(tpgt_del_list, tpgt);
1007 		idm_refcnt_wait_ref(&tpgt->tpgt_refcnt);
1008 		iscsit_tpgt_destroy(tpgt);
1009 	}
1010 }
1011 
1012 void
iscsit_tgt_unref(void * tgt_void)1013 iscsit_tgt_unref(void *tgt_void)
1014 {
1015 	iscsit_tgt_t	*tgt = tgt_void;
1016 
1017 	ISCSIT_GLOBAL_LOCK(RW_WRITER);
1018 	list_remove(&iscsit_global.global_deleted_target_list, tgt);
1019 	ISCSIT_GLOBAL_UNLOCK();
1020 	iscsit_tgt_destroy(tgt);
1021 }
1022 
1023 void
iscsit_tgt_async_wait_ref(iscsit_tgt_t * tgt,idm_refcnt_cb_t * cb_func)1024 iscsit_tgt_async_wait_ref(iscsit_tgt_t *tgt, idm_refcnt_cb_t *cb_func)
1025 {
1026 	idm_refcnt_async_wait_ref(&tgt->target_refcnt, cb_func);
1027 }
1028 
1029 static void
iscsit_tgt_destroy(iscsit_tgt_t * tgt)1030 iscsit_tgt_destroy(iscsit_tgt_t *tgt)
1031 {
1032 	iscsit_tpgt_t *tpgt, *next_tpgt;
1033 
1034 	ASSERT(tgt->target_state == TS_DELETING ||
1035 	    (tgt->target_state == TS_CREATED &&
1036 	    tgt->target_stmf_lport_registered == 0));
1037 
1038 	/*
1039 	 * Destroy all target portal group tags
1040 	 */
1041 	mutex_enter(&tgt->target_mutex);
1042 	for (tpgt = avl_first(&tgt->target_tpgt_list);
1043 	    tpgt != NULL;
1044 	    tpgt = next_tpgt) {
1045 		next_tpgt = AVL_NEXT(&tgt->target_tpgt_list, tpgt);
1046 		avl_remove(&tgt->target_tpgt_list, tpgt);
1047 		iscsit_tpgt_destroy(tpgt);
1048 	}
1049 
1050 	if (tgt->target_props) {
1051 		nvlist_free(tgt->target_props);
1052 	}
1053 	mutex_exit(&tgt->target_mutex);
1054 
1055 	/*
1056 	 * Destroy target
1057 	 */
1058 	idm_refcnt_destroy(&tgt->target_sess_refcnt);
1059 	idm_refcnt_destroy(&tgt->target_refcnt);
1060 	list_destroy(&tgt->target_events);
1061 	avl_destroy(&tgt->target_tpgt_list);
1062 	avl_destroy(&tgt->target_sess_list);
1063 	mutex_destroy(&tgt->target_mutex);
1064 	if (tgt->target_stmf_lport->lport_alias)
1065 		strfree(tgt->target_stmf_lport->lport_alias);
1066 	stmf_free(tgt->target_stmf_lport); /* Also frees "tgt' */
1067 	iscsit_global_rele();
1068 }
1069 
1070 void
iscsit_tgt_hold(iscsit_tgt_t * tgt)1071 iscsit_tgt_hold(iscsit_tgt_t *tgt)
1072 {
1073 	idm_refcnt_hold(&tgt->target_refcnt);
1074 }
1075 
1076 void
iscsit_tgt_rele(iscsit_tgt_t * tgt)1077 iscsit_tgt_rele(iscsit_tgt_t *tgt)
1078 {
1079 	idm_refcnt_rele(&tgt->target_refcnt);
1080 }
1081 
1082 int
iscsit_tgt_avl_compare(const void * void_tgt1,const void * void_tgt2)1083 iscsit_tgt_avl_compare(const void *void_tgt1, const void *void_tgt2)
1084 {
1085 	const iscsit_tgt_t	*tgt1 = void_tgt1;
1086 	const iscsit_tgt_t	*tgt2 = void_tgt2;
1087 	int			result;
1088 
1089 	/*
1090 	 * Sort by ISID first then TSIH
1091 	 */
1092 	result = strcmp(tgt1->target_name, tgt2->target_name);
1093 	if (result < 0) {
1094 		return (-1);
1095 	} else if (result > 0) {
1096 		return (1);
1097 	}
1098 
1099 	return (0);
1100 }
1101 
1102 
1103 iscsit_tpgt_t *
iscsit_tgt_lookup_tpgt(iscsit_tgt_t * tgt,uint16_t tag)1104 iscsit_tgt_lookup_tpgt(iscsit_tgt_t *tgt, uint16_t tag)
1105 {
1106 	iscsit_tpgt_t *result;
1107 
1108 	mutex_enter(&tgt->target_mutex);
1109 	result = iscsit_tgt_lookup_tpgt_locked(tgt, tag);
1110 	mutex_exit(&tgt->target_mutex);
1111 
1112 	return (result);
1113 }
1114 
1115 static iscsit_tpgt_t *
iscsit_tgt_lookup_tpgt_locked(iscsit_tgt_t * tgt,uint16_t tag)1116 iscsit_tgt_lookup_tpgt_locked(iscsit_tgt_t *tgt, uint16_t tag)
1117 {
1118 	iscsit_tpgt_t	tmp_tpgt;
1119 	iscsit_tpgt_t	*result;
1120 
1121 	/* Caller holds tgt->target_mutex */
1122 	tmp_tpgt.tpgt_tag = tag;
1123 	if ((result = avl_find(&tgt->target_tpgt_list, &tmp_tpgt, NULL)) !=
1124 	    NULL) {
1125 		iscsit_tpgt_hold(result);
1126 	}
1127 
1128 	return (result);
1129 }
1130 
1131 iscsit_portal_t *
iscsit_tgt_lookup_portal(iscsit_tgt_t * tgt,struct sockaddr_storage * sa,iscsit_tpgt_t ** output_tpgt)1132 iscsit_tgt_lookup_portal(iscsit_tgt_t *tgt, struct sockaddr_storage *sa,
1133     iscsit_tpgt_t **output_tpgt)
1134 {
1135 	iscsit_tpgt_t	*tpgt;
1136 	iscsit_portal_t	*portal;
1137 
1138 	/* Caller holds tgt->target_mutex */
1139 	ASSERT(mutex_owned(&tgt->target_mutex));
1140 	for (tpgt = avl_first(&tgt->target_tpgt_list);
1141 	    tpgt != NULL;
1142 	    tpgt = AVL_NEXT(&tgt->target_tpgt_list, tpgt)) {
1143 		portal = iscsit_tpg_portal_lookup(tpgt->tpgt_tpg, sa);
1144 		if (portal) {
1145 			iscsit_tpgt_hold(tpgt);
1146 			*output_tpgt = tpgt;
1147 			return (portal);
1148 		}
1149 	}
1150 
1151 	return (NULL);
1152 }
1153 
1154 
1155 void
iscsit_tgt_bind_sess(iscsit_tgt_t * tgt,iscsit_sess_t * sess)1156 iscsit_tgt_bind_sess(iscsit_tgt_t *tgt, iscsit_sess_t *sess)
1157 {
1158 	if (tgt) {
1159 		sess->ist_lport = tgt->target_stmf_lport;
1160 		iscsit_tgt_hold(tgt);
1161 		idm_refcnt_hold(&tgt->target_sess_refcnt);
1162 		mutex_enter(&tgt->target_mutex);
1163 		avl_add(&tgt->target_sess_list, sess);
1164 		mutex_exit(&tgt->target_mutex);
1165 	} else {
1166 		/* Discovery session */
1167 		sess->ist_lport = NULL;
1168 		ISCSIT_GLOBAL_LOCK(RW_WRITER);
1169 		avl_add(&iscsit_global.global_discovery_sessions, sess);
1170 		ISCSIT_GLOBAL_UNLOCK();
1171 	}
1172 }
1173 
1174 void
iscsit_tgt_unbind_sess(iscsit_tgt_t * tgt,iscsit_sess_t * sess)1175 iscsit_tgt_unbind_sess(iscsit_tgt_t *tgt, iscsit_sess_t *sess)
1176 {
1177 	if (tgt) {
1178 		mutex_enter(&tgt->target_mutex);
1179 		avl_remove(&tgt->target_sess_list, sess);
1180 		mutex_exit(&tgt->target_mutex);
1181 		sess->ist_tgt = (iscsit_tgt_t *)SESS_UNBOUND_FROM_TGT;
1182 		idm_refcnt_rele(&tgt->target_sess_refcnt);
1183 		iscsit_tgt_rele(tgt);
1184 	} else {
1185 		/* Discovery session */
1186 		ISCSIT_GLOBAL_LOCK(RW_WRITER);
1187 		avl_remove(&iscsit_global.global_discovery_sessions, sess);
1188 		ISCSIT_GLOBAL_UNLOCK();
1189 	}
1190 }
1191 
1192 #define	LOCK_FOR_SESS_LOOKUP(lookup_tgt) {			\
1193 	if ((lookup_tgt) == NULL) {				\
1194 		ISCSIT_GLOBAL_LOCK(RW_READER);			\
1195 	} else {						\
1196 		mutex_enter(&(lookup_tgt)->target_mutex);	\
1197 	}							\
1198 }
1199 
1200 #define	UNLOCK_FOR_SESS_LOOKUP(lookup_tgt) {			\
1201 	if ((lookup_tgt) == NULL) {				\
1202 		ISCSIT_GLOBAL_UNLOCK();				\
1203 	} else {						\
1204 		mutex_exit(&(lookup_tgt)->target_mutex);	\
1205 	}							\
1206 }
1207 
1208 iscsit_sess_t *
iscsit_tgt_lookup_sess(iscsit_tgt_t * tgt,char * initiator_name,uint8_t * isid,uint16_t tsih,uint16_t tag)1209 iscsit_tgt_lookup_sess(iscsit_tgt_t *tgt, char *initiator_name,
1210     uint8_t *isid, uint16_t tsih, uint16_t tag)
1211 {
1212 	iscsit_sess_t	tmp_sess;
1213 	avl_tree_t	*sess_avl;
1214 	avl_index_t	where;
1215 	iscsit_sess_t	*result;
1216 
1217 	/*
1218 	 * If tgt is NULL then we are looking for a discovery session
1219 	 */
1220 	if (tgt == NULL) {
1221 		sess_avl = &iscsit_global.global_discovery_sessions;
1222 	} else {
1223 		sess_avl = &tgt->target_sess_list;
1224 	}
1225 
1226 	LOCK_FOR_SESS_LOOKUP(tgt);
1227 	if (avl_numnodes(sess_avl) == 0) {
1228 		UNLOCK_FOR_SESS_LOOKUP(tgt);
1229 		return (NULL);
1230 	}
1231 
1232 	/*
1233 	 * We'll try to find a session matching ISID + TSIH first.  If we
1234 	 * can't find one then we will return the closest match.  If the
1235 	 * caller needs an exact match it must compare the TSIH after
1236 	 * the session is returned.
1237 	 *
1238 	 * The reason we do this "fuzzy matching" is to allow matching
1239 	 * sessions with different TSIH values on the same AVL list.  This
1240 	 * makes session reinstatement much easier since the new session can
1241 	 * live on the list at the same time as the old session is cleaning up.
1242 	 */
1243 	bcopy(isid, tmp_sess.ist_isid, ISCSI_ISID_LEN);
1244 	tmp_sess.ist_initiator_name = initiator_name;
1245 	tmp_sess.ist_tsih = tsih;
1246 	tmp_sess.ist_tpgt_tag = tag;
1247 
1248 	result = avl_find(sess_avl, &tmp_sess, &where);
1249 	if (result != NULL) {
1250 		goto found_result;
1251 	}
1252 
1253 	/*
1254 	 * avl_find_nearest() may return a result with a different ISID so
1255 	 * we should only return a result if the name and ISID match
1256 	 */
1257 	result = avl_nearest(sess_avl, where, AVL_BEFORE);
1258 	if ((result != NULL) &&
1259 	    (strcmp(result->ist_initiator_name, initiator_name) == 0) &&
1260 	    (memcmp(result->ist_isid, isid, ISCSI_ISID_LEN) == 0) &&
1261 	    (result->ist_tpgt_tag == tag)) {
1262 		goto found_result;
1263 	}
1264 
1265 	result = avl_nearest(sess_avl, where, AVL_AFTER);
1266 	if ((result != NULL) &&
1267 	    (strcmp(result->ist_initiator_name, initiator_name) == 0) &&
1268 	    (memcmp(result->ist_isid, isid, ISCSI_ISID_LEN) == 0) &&
1269 	    (result->ist_tpgt_tag == tag)) {
1270 		goto found_result;
1271 	}
1272 
1273 	result = NULL;
1274 
1275 found_result:
1276 	if ((result != NULL) &&
1277 	    (iscsit_sess_check_hold(result) != IDM_STATUS_SUCCESS)) {
1278 		result = NULL;
1279 	}
1280 	UNLOCK_FOR_SESS_LOOKUP(tgt);
1281 	return (result);
1282 }
1283 
1284 static idm_status_t
iscsit_tgt_merge_tpgt(iscsit_tgt_t * tgt,it_tgt_t * cfg_tgt,list_t * tpgt_del_list)1285 iscsit_tgt_merge_tpgt(iscsit_tgt_t *tgt, it_tgt_t *cfg_tgt,
1286     list_t *tpgt_del_list)
1287 {
1288 	iscsit_tpgt_t	*tpgt, *next_tpgt;
1289 	it_tpgt_t	*cfg_tpgt;
1290 	idm_status_t	status = IDM_STATUS_SUCCESS;
1291 
1292 	/*
1293 	 * 1. >> Lock <<
1294 	 * 2. Removing all objects and place on a temp list
1295 	 * 3. Add new objects
1296 	 * 4. >> Unlock <<
1297 	 * 5. tpgt_del_list contains deleted objects
1298 	 */
1299 	ASSERT(avl_is_empty(&tgt->target_tpgt_list) ||
1300 	    (tpgt_del_list != NULL));
1301 
1302 	if (tpgt_del_list) {
1303 		for (tpgt = avl_first(&tgt->target_tpgt_list);
1304 		    tpgt != NULL; tpgt = next_tpgt) {
1305 			next_tpgt = AVL_NEXT(&tgt->target_tpgt_list, tpgt);
1306 			avl_remove(&tgt->target_tpgt_list, tpgt);
1307 			if (tgt->target_state == TS_STMF_ONLINE) {
1308 				tpgt->tpgt_needs_tpg_offline = B_TRUE;
1309 			}
1310 			list_insert_tail(tpgt_del_list, tpgt);
1311 		}
1312 	}
1313 
1314 	if (cfg_tgt->tgt_tpgt_list != NULL) {
1315 		/* Add currently defined TPGTs */
1316 		for (cfg_tpgt = cfg_tgt->tgt_tpgt_list;
1317 		    cfg_tpgt != NULL;
1318 		    cfg_tpgt = cfg_tpgt->tpgt_next) {
1319 			tpgt = iscsit_tpgt_create(cfg_tpgt);
1320 			if (tpgt == NULL) {
1321 				/*
1322 				 * There is a problem in the configuration we
1323 				 * received from the ioctl -- a missing tpg.
1324 				 * All the unbind operations have already
1325 				 * taken place.  To leave the system in a
1326 				 * non-panic'd state, use the default tpgt.
1327 				 */
1328 				status = IDM_STATUS_FAIL;
1329 				continue;
1330 			}
1331 			if (tgt->target_state == TS_STMF_ONLINE) {
1332 				(void) iscsit_tpg_online(tpgt->tpgt_tpg);
1333 			}
1334 			avl_add(&tgt->target_tpgt_list, tpgt);
1335 		}
1336 	}
1337 
1338 	/* If no TPGTs defined, add the default TPGT */
1339 	if (avl_numnodes(&tgt->target_tpgt_list) == 0) {
1340 		tpgt = iscsit_tpgt_create_default();
1341 		if (tgt->target_state == TS_STMF_ONLINE) {
1342 			(void) iscsit_tpg_online(tpgt->tpgt_tpg);
1343 		}
1344 		avl_add(&tgt->target_tpgt_list, tpgt);
1345 	}
1346 
1347 	return (status);
1348 }
1349 
1350 static iscsit_tpgt_t *
iscsit_tpgt_create(it_tpgt_t * cfg_tpgt)1351 iscsit_tpgt_create(it_tpgt_t *cfg_tpgt)
1352 {
1353 	iscsit_tpg_t	*tpg;
1354 	iscsit_tpgt_t	*result;
1355 
1356 	/* This takes a reference on the TPG */
1357 	tpg = iscsit_tpg_lookup_locked(cfg_tpgt->tpgt_tpg_name);
1358 	if (tpg == NULL)
1359 		return (NULL);
1360 
1361 	result = kmem_zalloc(sizeof (*result), KM_SLEEP);
1362 
1363 	result->tpgt_tpg = tpg;
1364 	result->tpgt_tag = cfg_tpgt->tpgt_tag;
1365 
1366 	return (result);
1367 }
1368 
1369 iscsit_tpgt_t *
iscsit_tpgt_create_default()1370 iscsit_tpgt_create_default()
1371 {
1372 	iscsit_tpgt_t	*result;
1373 
1374 	result = kmem_zalloc(sizeof (*result), KM_SLEEP);
1375 
1376 	result->tpgt_tpg = iscsit_global.global_default_tpg;
1377 	iscsit_tpg_hold(result->tpgt_tpg);
1378 	result->tpgt_tag = ISCSIT_DEFAULT_TPGT;
1379 
1380 	return (result);
1381 }
1382 
1383 void
iscsit_tpgt_destroy(iscsit_tpgt_t * tpgt)1384 iscsit_tpgt_destroy(iscsit_tpgt_t *tpgt)
1385 {
1386 	if (tpgt->tpgt_needs_tpg_offline) {
1387 		iscsit_tpg_offline(tpgt->tpgt_tpg);
1388 	}
1389 	iscsit_tpg_rele(tpgt->tpgt_tpg);
1390 	kmem_free(tpgt, sizeof (*tpgt));
1391 }
1392 
1393 void
iscsit_tpgt_hold(iscsit_tpgt_t * tpgt)1394 iscsit_tpgt_hold(iscsit_tpgt_t *tpgt)
1395 {
1396 	idm_refcnt_hold(&tpgt->tpgt_refcnt);
1397 }
1398 
1399 void
iscsit_tpgt_rele(iscsit_tpgt_t * tpgt)1400 iscsit_tpgt_rele(iscsit_tpgt_t *tpgt)
1401 {
1402 	idm_refcnt_rele(&tpgt->tpgt_refcnt);
1403 }
1404 
1405 int
iscsit_tpgt_avl_compare(const void * void_tpgt1,const void * void_tpgt2)1406 iscsit_tpgt_avl_compare(const void *void_tpgt1, const void *void_tpgt2)
1407 {
1408 	const iscsit_tpgt_t	*tpgt1 = void_tpgt1;
1409 	const iscsit_tpgt_t	*tpgt2 = void_tpgt2;
1410 
1411 	if (tpgt1->tpgt_tag < tpgt2->tpgt_tag)
1412 		return (-1);
1413 	else if (tpgt1->tpgt_tag > tpgt2->tpgt_tag)
1414 		return (1);
1415 
1416 	return (0);
1417 }
1418 
1419 static idm_status_t
iscsit_tgt_online(iscsit_tgt_t * tgt)1420 iscsit_tgt_online(iscsit_tgt_t *tgt)
1421 {
1422 	iscsit_tpgt_t		*tpgt, *tpgt_fail;
1423 	idm_status_t		rc;
1424 
1425 	mutex_enter(&tgt->target_mutex);
1426 
1427 	ASSERT(tgt->target_sess_list.avl_numnodes == 0);
1428 	idm_refcnt_reset(&tgt->target_sess_refcnt);
1429 	for (tpgt = avl_first(&tgt->target_tpgt_list);
1430 	    tpgt != NULL;
1431 	    tpgt = AVL_NEXT(&tgt->target_tpgt_list, tpgt)) {
1432 		rc = iscsit_tpg_online(tpgt->tpgt_tpg);
1433 		if (rc != IDM_STATUS_SUCCESS) {
1434 			tpgt_fail = tpgt;
1435 			goto tgt_online_fail;
1436 		}
1437 	}
1438 
1439 	mutex_exit(&tgt->target_mutex);
1440 
1441 	return (IDM_STATUS_SUCCESS);
1442 
1443 tgt_online_fail:
1444 	/* Offline all the tpgs we successfully onlined up to the failure */
1445 	for (tpgt = avl_first(&tgt->target_tpgt_list);
1446 	    tpgt != tpgt_fail;
1447 	    tpgt = AVL_NEXT(&tgt->target_tpgt_list, tpgt)) {
1448 		iscsit_tpg_offline(tpgt->tpgt_tpg);
1449 	}
1450 	mutex_exit(&tgt->target_mutex);
1451 	return (rc);
1452 }
1453 
1454 static void
iscsit_tgt_offline_cb(void * tgt_void)1455 iscsit_tgt_offline_cb(void *tgt_void)
1456 {
1457 	iscsit_tgt_t *tgt = tgt_void;
1458 	stmf_change_status_t	scs;
1459 
1460 	iscsit_tgt_sm_event(tgt, TE_OFFLINE_COMPLETE);
1461 
1462 	scs.st_completion_status = STMF_SUCCESS;
1463 	scs.st_additional_info = NULL;
1464 	(void) stmf_ctl(STMF_CMD_LPORT_OFFLINE_COMPLETE,
1465 	    tgt->target_stmf_lport, &scs);
1466 }
1467 
1468 static void
iscsit_tgt_offline(iscsit_tgt_t * tgt)1469 iscsit_tgt_offline(iscsit_tgt_t *tgt)
1470 {
1471 	iscsit_tpgt_t		*tpgt;
1472 	iscsit_sess_t		*ist;
1473 
1474 	mutex_enter(&tgt->target_mutex);
1475 
1476 	/* Offline target portal groups */
1477 	for (tpgt = avl_first(&tgt->target_tpgt_list);
1478 	    tpgt != NULL;
1479 	    tpgt = AVL_NEXT(&tgt->target_tpgt_list, tpgt)) {
1480 		iscsit_tpg_offline(tpgt->tpgt_tpg);
1481 	}
1482 
1483 	/* Close any active sessions */
1484 	for (ist = avl_first(&tgt->target_sess_list);
1485 	    ist != NULL;
1486 	    ist = AVL_NEXT(&tgt->target_sess_list, ist)) {
1487 		/*
1488 		 * This is not a synchronous operation but after all
1489 		 * sessions have been cleaned up there will be no
1490 		 * more session-related holds on the target.
1491 		 */
1492 		iscsit_sess_close(ist);
1493 	}
1494 
1495 	mutex_exit(&tgt->target_mutex);
1496 
1497 	/*
1498 	 * Wait for all the sessions to quiesce.
1499 	 */
1500 	idm_refcnt_async_wait_ref(&tgt->target_sess_refcnt,
1501 	    &iscsit_tgt_offline_cb);
1502 }
1503 
1504 it_cfg_status_t
iscsit_config_merge_tpg(it_config_t * cfg,list_t * tpg_del_list)1505 iscsit_config_merge_tpg(it_config_t *cfg, list_t *tpg_del_list)
1506 {
1507 	it_tpg_t	*cfg_tpg;
1508 	iscsit_tpg_t	*tpg, *next_tpg;
1509 
1510 	/*
1511 	 * 1. >> Lock <<
1512 	 * 2. Removing deleted objects and place on a temp list
1513 	 * 3. Add new objects
1514 	 * 4. >> Unlock <<
1515 	 * 5. tpg_del_list contains objects to destroy
1516 	 */
1517 	for (tpg = avl_first(&iscsit_global.global_tpg_list);
1518 	    tpg != NULL;
1519 	    tpg = next_tpg) {
1520 		next_tpg = AVL_NEXT(&iscsit_global.global_tpg_list, tpg);
1521 
1522 		if (it_tpg_lookup(cfg, tpg->tpg_name) == NULL) {
1523 			/*
1524 			 * The policy around when to allow a target portal
1525 			 * group to be deleted is implemented in libiscsit.
1526 			 * By the time the request gets to the kernel module
1527 			 * we expect that it conforms to policy so we will
1528 			 * cleanup all references to TPG and destroy it if it
1529 			 * is possible to do so.
1530 			 *
1531 			 */
1532 			avl_remove(&iscsit_global.global_tpg_list, tpg);
1533 			list_insert_tail(tpg_del_list, tpg);
1534 		}
1535 	}
1536 
1537 	/* Now walk through the list of configured target portal groups */
1538 	for (cfg_tpg = cfg->config_tpg_list;
1539 	    cfg_tpg != NULL;
1540 	    cfg_tpg = cfg_tpg->tpg_next) {
1541 		/* See if we have an existing target portal group */
1542 		tpg = iscsit_tpg_lookup_locked(cfg_tpg->tpg_name);
1543 
1544 		if (tpg == NULL) {
1545 			tpg = iscsit_tpg_create(cfg_tpg);
1546 			ASSERT(tpg != NULL);
1547 			avl_add(&iscsit_global.global_tpg_list, tpg);
1548 		} else {
1549 			mutex_enter(&tpg->tpg_mutex);
1550 			iscsit_tpg_modify(tpg, cfg_tpg);
1551 			mutex_exit(&tpg->tpg_mutex);
1552 			iscsit_tpg_rele(tpg);
1553 		}
1554 	}
1555 
1556 	return (ITCFG_SUCCESS);
1557 }
1558 
1559 
1560 void
iscsit_config_destroy_tpgs(list_t * tpg_del_list)1561 iscsit_config_destroy_tpgs(list_t *tpg_del_list)
1562 {
1563 	iscsit_tpg_t	*tpg, *next_tpg;
1564 
1565 	/* Now finish destroying the target portal groups */
1566 	for (tpg = list_head(tpg_del_list);
1567 	    tpg != NULL;
1568 	    tpg = next_tpg) {
1569 		next_tpg = list_next(tpg_del_list, tpg);
1570 		list_remove(tpg_del_list, tpg);
1571 		idm_refcnt_wait_ref(&tpg->tpg_refcnt);
1572 
1573 		/* Kill it */
1574 		iscsit_tpg_destroy(tpg);
1575 	}
1576 }
1577 
1578 iscsit_tpg_t *
iscsit_tpg_lookup(char * tpg_name)1579 iscsit_tpg_lookup(char *tpg_name)
1580 {
1581 	iscsit_tpg_t *result;
1582 
1583 	ISCSIT_GLOBAL_LOCK(RW_READER);
1584 	result = iscsit_tpg_lookup_locked(tpg_name);
1585 	ISCSIT_GLOBAL_UNLOCK();
1586 
1587 	return (result);
1588 }
1589 
1590 static iscsit_tpg_t *
iscsit_tpg_lookup_locked(char * tpg_name)1591 iscsit_tpg_lookup_locked(char *tpg_name)
1592 {
1593 	iscsit_tpg_t	tmp_tpg;
1594 	iscsit_tpg_t	*result;
1595 
1596 	(void) strlcpy(tmp_tpg.tpg_name, tpg_name, MAX_ISCSI_NODENAMELEN);
1597 	if ((result = avl_find(&iscsit_global.global_tpg_list,
1598 	    &tmp_tpg, NULL)) != NULL) {
1599 		iscsit_tpg_hold(result);
1600 	}
1601 
1602 	return (result);
1603 }
1604 
1605 iscsit_tpg_t *
iscsit_tpg_create(it_tpg_t * cfg_tpg)1606 iscsit_tpg_create(it_tpg_t *cfg_tpg)
1607 {
1608 	iscsit_tpg_t *tpg;
1609 
1610 	tpg = kmem_zalloc(sizeof (*tpg), KM_SLEEP);
1611 
1612 	mutex_init(&tpg->tpg_mutex, NULL, MUTEX_DEFAULT, NULL);
1613 	(void) strlcpy(tpg->tpg_name, cfg_tpg->tpg_name, MAX_TPG_NAMELEN);
1614 	avl_create(&tpg->tpg_portal_list, iscsit_portal_avl_compare,
1615 	    sizeof (iscsit_portal_t), offsetof(iscsit_portal_t, portal_tpg_ln));
1616 	idm_refcnt_init(&tpg->tpg_refcnt, tpg);
1617 
1618 	mutex_enter(&tpg->tpg_mutex);
1619 	iscsit_tpg_modify(tpg, cfg_tpg);
1620 	mutex_exit(&tpg->tpg_mutex);
1621 	iscsit_global_hold();
1622 
1623 	return (tpg);
1624 }
1625 
1626 static void
iscsit_tpg_modify(iscsit_tpg_t * tpg,it_tpg_t * cfg_tpg)1627 iscsit_tpg_modify(iscsit_tpg_t *tpg, it_tpg_t *cfg_tpg)
1628 {
1629 	iscsit_portal_t		*portal, *next_portal;
1630 	it_portal_t		*cfg_portal;
1631 
1632 	/* Update portals */
1633 	for (portal = avl_first(&tpg->tpg_portal_list);
1634 	    portal != NULL;
1635 	    portal = next_portal) {
1636 		next_portal = AVL_NEXT(&tpg->tpg_portal_list, portal);
1637 		if (it_portal_lookup(cfg_tpg, &portal->portal_addr) == NULL) {
1638 			avl_remove(&tpg->tpg_portal_list, portal);
1639 			iscsit_portal_delete(portal);
1640 			/*
1641 			 * If the last portal is deleted from the target
1642 			 * portal group, then the tpg->tpg_online count
1643 			 * must be decremented. The other two callers of
1644 			 * iscsit_portal_delete() destroy the target portal
1645 			 * after deleting the portal so it is not necessary
1646 			 * to decrement the tpg->tpg_online count.
1647 			 */
1648 			if (avl_is_empty(&tpg->tpg_portal_list)) {
1649 				tpg->tpg_online--;
1650 			}
1651 		}
1652 	}
1653 
1654 	for (cfg_portal = cfg_tpg->tpg_portal_list;
1655 	    cfg_portal != NULL;
1656 	    cfg_portal = cfg_portal->portal_next) {
1657 		if ((portal = iscsit_tpg_portal_lookup_locked(tpg,
1658 		    &cfg_portal->portal_addr)) == NULL) {
1659 			(void) iscsit_portal_create(tpg,
1660 			    &cfg_portal->portal_addr);
1661 		} else {
1662 			iscsit_portal_rele(portal);
1663 		}
1664 	}
1665 }
1666 
1667 void
iscsit_tpg_destroy(iscsit_tpg_t * tpg)1668 iscsit_tpg_destroy(iscsit_tpg_t *tpg)
1669 {
1670 	iscsit_portal_t *portal, *next_portal;
1671 
1672 	for (portal = avl_first(&tpg->tpg_portal_list);
1673 	    portal != NULL;
1674 	    portal = next_portal) {
1675 		next_portal = AVL_NEXT(&tpg->tpg_portal_list, portal);
1676 		avl_remove(&tpg->tpg_portal_list, portal);
1677 		iscsit_portal_delete(portal);
1678 	}
1679 
1680 	idm_refcnt_wait_ref(&tpg->tpg_refcnt);
1681 	idm_refcnt_destroy(&tpg->tpg_refcnt);
1682 	avl_destroy(&tpg->tpg_portal_list);
1683 	mutex_destroy(&tpg->tpg_mutex);
1684 	kmem_free(tpg, sizeof (*tpg));
1685 	iscsit_global_rele();
1686 }
1687 
1688 void
iscsit_tpg_hold(iscsit_tpg_t * tpg)1689 iscsit_tpg_hold(iscsit_tpg_t *tpg)
1690 {
1691 	idm_refcnt_hold(&tpg->tpg_refcnt);
1692 }
1693 
1694 void
iscsit_tpg_rele(iscsit_tpg_t * tpg)1695 iscsit_tpg_rele(iscsit_tpg_t *tpg)
1696 {
1697 	idm_refcnt_rele(&tpg->tpg_refcnt);
1698 }
1699 
1700 iscsit_tpg_t *
iscsit_tpg_createdefault()1701 iscsit_tpg_createdefault()
1702 {
1703 	iscsit_tpg_t *tpg;
1704 
1705 	tpg = kmem_zalloc(sizeof (*tpg), KM_SLEEP);
1706 
1707 	mutex_init(&tpg->tpg_mutex, NULL, MUTEX_DEFAULT, NULL);
1708 	(void) strlcpy(tpg->tpg_name, ISCSIT_DEFAULT_TPG, MAX_TPG_NAMELEN);
1709 	avl_create(&tpg->tpg_portal_list, iscsit_portal_avl_compare,
1710 	    sizeof (iscsit_portal_t), offsetof(iscsit_portal_t, portal_tpg_ln));
1711 	idm_refcnt_init(&tpg->tpg_refcnt, tpg);
1712 
1713 	/* Now create default portal */
1714 	if (iscsit_portal_create(tpg, NULL) == NULL) {
1715 		iscsit_tpg_destroy(tpg);
1716 		return (NULL);
1717 	}
1718 
1719 	return (tpg);
1720 }
1721 
1722 void
iscsit_tpg_destroydefault(iscsit_tpg_t * tpg)1723 iscsit_tpg_destroydefault(iscsit_tpg_t *tpg)
1724 {
1725 	iscsit_portal_t *portal;
1726 
1727 	portal = avl_first(&tpg->tpg_portal_list);
1728 	ASSERT(portal != NULL);
1729 	avl_remove(&tpg->tpg_portal_list, portal);
1730 	iscsit_portal_delete(portal);
1731 
1732 	idm_refcnt_wait_ref(&tpg->tpg_refcnt);
1733 	idm_refcnt_destroy(&tpg->tpg_refcnt);
1734 	avl_destroy(&tpg->tpg_portal_list);
1735 	mutex_destroy(&tpg->tpg_mutex);
1736 	kmem_free(tpg, sizeof (*tpg));
1737 }
1738 
1739 int
iscsit_tpg_avl_compare(const void * void_tpg1,const void * void_tpg2)1740 iscsit_tpg_avl_compare(const void *void_tpg1, const void *void_tpg2)
1741 {
1742 	const iscsit_tpg_t	*tpg1 = void_tpg1;
1743 	const iscsit_tpg_t	*tpg2 = void_tpg2;
1744 	int			result;
1745 
1746 	/*
1747 	 * Sort by ISID first then TSIH
1748 	 */
1749 	result = strcmp(tpg1->tpg_name, tpg2->tpg_name);
1750 	if (result < 0) {
1751 		return (-1);
1752 	} else if (result > 0) {
1753 		return (1);
1754 	}
1755 
1756 	return (0);
1757 }
1758 
1759 idm_status_t
iscsit_tpg_online(iscsit_tpg_t * tpg)1760 iscsit_tpg_online(iscsit_tpg_t *tpg)
1761 {
1762 	iscsit_portal_t *portal, *portal_fail;
1763 	idm_status_t	rc;
1764 
1765 	mutex_enter(&tpg->tpg_mutex);
1766 	if (tpg->tpg_online == 0) {
1767 		for (portal = avl_first(&tpg->tpg_portal_list);
1768 		    portal != NULL;
1769 		    portal = AVL_NEXT(&tpg->tpg_portal_list, portal)) {
1770 			rc = iscsit_portal_online(portal);
1771 			if (rc != IDM_STATUS_SUCCESS) {
1772 				portal_fail = portal;
1773 				goto tpg_online_fail;
1774 			}
1775 		}
1776 	}
1777 	tpg->tpg_online++;
1778 
1779 	mutex_exit(&tpg->tpg_mutex);
1780 	return (IDM_STATUS_SUCCESS);
1781 
1782 tpg_online_fail:
1783 	/* Offline all the portals we successfully onlined up to the failure */
1784 	for (portal = avl_first(&tpg->tpg_portal_list);
1785 	    portal != portal_fail;
1786 	    portal = AVL_NEXT(&tpg->tpg_portal_list, portal)) {
1787 		iscsit_portal_offline(portal);
1788 	}
1789 	mutex_exit(&tpg->tpg_mutex);
1790 	return (rc);
1791 }
1792 
1793 void
iscsit_tpg_offline(iscsit_tpg_t * tpg)1794 iscsit_tpg_offline(iscsit_tpg_t *tpg)
1795 {
1796 	iscsit_portal_t *portal;
1797 
1798 	mutex_enter(&tpg->tpg_mutex);
1799 	tpg->tpg_online--;
1800 	if (tpg->tpg_online == 0) {
1801 		for (portal = avl_first(&tpg->tpg_portal_list);
1802 		    portal != NULL;
1803 		    portal = AVL_NEXT(&tpg->tpg_portal_list, portal)) {
1804 			iscsit_portal_offline(portal);
1805 		}
1806 	}
1807 	mutex_exit(&tpg->tpg_mutex);
1808 }
1809 
1810 iscsit_portal_t *
iscsit_tpg_portal_lookup(iscsit_tpg_t * tpg,struct sockaddr_storage * sa)1811 iscsit_tpg_portal_lookup(iscsit_tpg_t *tpg, struct sockaddr_storage *sa)
1812 {
1813 	iscsit_portal_t	*result;
1814 
1815 	mutex_enter(&tpg->tpg_mutex);
1816 	result = iscsit_tpg_portal_lookup_locked(tpg, sa);
1817 	mutex_exit(&tpg->tpg_mutex);
1818 
1819 	return (result);
1820 }
1821 
1822 static iscsit_portal_t *
iscsit_tpg_portal_lookup_locked(iscsit_tpg_t * tpg,struct sockaddr_storage * sa)1823 iscsit_tpg_portal_lookup_locked(iscsit_tpg_t *tpg,
1824     struct sockaddr_storage *sa)
1825 {
1826 	iscsit_portal_t	tmp_portal;
1827 	iscsit_portal_t	*result;
1828 
1829 	/* Caller holds tpg->tpg_mutex */
1830 	bcopy(sa, &tmp_portal.portal_addr, sizeof (*sa));
1831 	if ((result = avl_find(&tpg->tpg_portal_list, &tmp_portal, NULL)) !=
1832 	    NULL) {
1833 		iscsit_portal_hold(result);
1834 	}
1835 
1836 	return (result);
1837 }
1838 
1839 iscsit_portal_t *
iscsit_portal_create(iscsit_tpg_t * tpg,struct sockaddr_storage * sa)1840 iscsit_portal_create(iscsit_tpg_t *tpg, struct sockaddr_storage *sa)
1841 {
1842 	iscsit_portal_t *portal;
1843 
1844 	portal = kmem_zalloc(sizeof (*portal), KM_SLEEP);
1845 	/*
1846 	 * If (sa == NULL) then we are being asked to create the default
1847 	 * portal -- targets will use this portal when no portals are
1848 	 * explicitly configured.
1849 	 */
1850 	if (sa == NULL) {
1851 		portal->portal_default = B_TRUE;
1852 	} else {
1853 		portal->portal_default = B_FALSE;
1854 		bcopy(sa, &portal->portal_addr, sizeof (*sa));
1855 	}
1856 
1857 	idm_refcnt_init(&portal->portal_refcnt, portal);
1858 
1859 	/*
1860 	 * Add this portal to the list
1861 	 */
1862 	avl_add(&tpg->tpg_portal_list, portal);
1863 
1864 	return (portal);
1865 }
1866 
1867 void
iscsit_portal_delete(iscsit_portal_t * portal)1868 iscsit_portal_delete(iscsit_portal_t *portal)
1869 {
1870 	if (portal->portal_online > 0) {
1871 		iscsit_portal_offline(portal);
1872 	}
1873 
1874 	if (portal->portal_online == 0) {
1875 		ASSERT(portal->portal_svc == NULL);
1876 		idm_refcnt_destroy(&portal->portal_refcnt);
1877 		kmem_free(portal, sizeof (*portal));
1878 	}
1879 }
1880 
1881 void
iscsit_portal_hold(iscsit_portal_t * portal)1882 iscsit_portal_hold(iscsit_portal_t *portal)
1883 {
1884 	idm_refcnt_hold(&portal->portal_refcnt);
1885 }
1886 
1887 void
iscsit_portal_rele(iscsit_portal_t * portal)1888 iscsit_portal_rele(iscsit_portal_t *portal)
1889 {
1890 	idm_refcnt_rele(&portal->portal_refcnt);
1891 }
1892 
1893 int
iscsit_portal_avl_compare(const void * void_portal1,const void * void_portal2)1894 iscsit_portal_avl_compare(const void *void_portal1, const void *void_portal2)
1895 {
1896 	const iscsit_portal_t			*portal1 = void_portal1;
1897 	const iscsit_portal_t			*portal2 = void_portal2;
1898 	const struct sockaddr_storage		*ss1, *ss2;
1899 	const struct in_addr			*in1, *in2;
1900 	const struct in6_addr			*in61, *in62;
1901 	int i;
1902 
1903 	/*
1904 	 * Compare ports, then address family, then ip address
1905 	 */
1906 	ss1 = &portal1->portal_addr;
1907 	ss2 = &portal2->portal_addr;
1908 	if (((struct sockaddr_in *)ss1)->sin_port !=
1909 	    ((struct sockaddr_in *)ss2)->sin_port) {
1910 		if (((struct sockaddr_in *)ss1)->sin_port >
1911 		    ((struct sockaddr_in *)ss2)->sin_port)
1912 			return (1);
1913 		else
1914 			return (-1);
1915 	}
1916 
1917 	/*
1918 	 * ports are the same
1919 	 */
1920 	if (ss1->ss_family != ss2->ss_family) {
1921 		if (ss1->ss_family == AF_INET)
1922 			return (1);
1923 		else
1924 			return (-1);
1925 	}
1926 	/*
1927 	 * address families are the same
1928 	 */
1929 	if (ss1->ss_family == AF_INET) {
1930 		in1 = &((struct sockaddr_in *)ss1)->sin_addr;
1931 		in2 = &((struct sockaddr_in *)ss2)->sin_addr;
1932 
1933 		if (in1->s_addr > in2->s_addr)
1934 			return (1);
1935 		else if (in1->s_addr < in2->s_addr)
1936 			return (-1);
1937 		else
1938 			return (0);
1939 	} else if (ss1->ss_family == AF_INET6) {
1940 		in61 = &((struct sockaddr_in6 *)ss1)->sin6_addr;
1941 		in62 = &((struct sockaddr_in6 *)ss2)->sin6_addr;
1942 
1943 		for (i = 0; i < 4; i++) {
1944 			if (in61->s6_addr32[i] > in62->s6_addr32[i])
1945 				return (1);
1946 			else if (in61->s6_addr32[i] < in62->s6_addr32[i])
1947 				return (-1);
1948 		}
1949 		return (0);
1950 	} else
1951 		cmn_err(CE_WARN,
1952 		    "iscsit_portal_avl_compare: unknown ss_family %d",
1953 		    ss1->ss_family);
1954 
1955 	return (1);
1956 }
1957 
1958 
1959 idm_status_t
iscsit_portal_online(iscsit_portal_t * portal)1960 iscsit_portal_online(iscsit_portal_t *portal)
1961 {
1962 	idm_status_t rc = 0;
1963 	idm_svc_t	*svc;
1964 	idm_svc_req_t	sr;
1965 	uint16_t	port;
1966 	struct sockaddr_in *sin;
1967 
1968 	/* Caller holds parent TPG mutex */
1969 	if (portal->portal_online == 0) {
1970 		/*
1971 		 * If there is no existing IDM service instance for this port,
1972 		 * create one.  If the service exists, then the lookup,
1973 		 * creates a reference on the existing service.
1974 		 */
1975 		sin = (struct sockaddr_in *)&portal->portal_addr;
1976 		port = ntohs(sin->sin_port);
1977 		if (port == 0)
1978 			port = ISCSI_LISTEN_PORT;
1979 		ASSERT(portal->portal_svc == NULL);
1980 		if ((svc = idm_tgt_svc_lookup(port)) == NULL) {
1981 			sr.sr_port = port;
1982 			sr.sr_li = iscsit_global.global_li;
1983 			sr.sr_conn_ops.icb_rx_scsi_cmd = &iscsit_op_scsi_cmd;
1984 			sr.sr_conn_ops.icb_rx_scsi_rsp = &iscsit_rx_scsi_rsp;
1985 			sr.sr_conn_ops.icb_rx_misc = &iscsit_rx_pdu;
1986 			sr.sr_conn_ops.icb_rx_error = &iscsit_rx_pdu_error;
1987 			sr.sr_conn_ops.icb_task_aborted = &iscsit_task_aborted;
1988 			sr.sr_conn_ops.icb_client_notify =
1989 			    &iscsit_client_notify;
1990 			sr.sr_conn_ops.icb_build_hdr = &iscsit_build_hdr;
1991 			sr.sr_conn_ops.icb_update_statsn =
1992 			    &iscsit_update_statsn;
1993 			sr.sr_conn_ops.icb_keepalive = &iscsit_keepalive;
1994 
1995 			if (idm_tgt_svc_create(&sr, &svc) !=
1996 			    IDM_STATUS_SUCCESS) {
1997 				return (IDM_STATUS_FAIL);
1998 			}
1999 
2000 			/* Get reference on the service we just created */
2001 			idm_tgt_svc_hold(svc);
2002 		}
2003 		if ((rc = idm_tgt_svc_online(svc)) != IDM_STATUS_SUCCESS) {
2004 			idm_tgt_svc_rele_and_destroy(svc);
2005 			return (IDM_STATUS_FAIL);
2006 		}
2007 		portal->portal_svc = svc;
2008 
2009 		/*
2010 		 * Only call iSNS for first online
2011 		 */
2012 		iscsit_isns_portal_online(portal);
2013 	}
2014 
2015 	portal->portal_online++;
2016 
2017 	return (rc);
2018 }
2019 
2020 void
iscsit_portal_offline(iscsit_portal_t * portal)2021 iscsit_portal_offline(iscsit_portal_t *portal)
2022 {
2023 	portal->portal_online--;
2024 
2025 	if (portal->portal_online == 0) {
2026 		/*
2027 		 * Only call iSNS for last offline
2028 		 */
2029 		iscsit_isns_portal_offline(portal);
2030 		idm_tgt_svc_offline(portal->portal_svc);
2031 		/* If service is unreferenced, destroy it too */
2032 		idm_tgt_svc_rele_and_destroy(portal->portal_svc);
2033 		portal->portal_svc = NULL;
2034 	}
2035 
2036 }
2037 
2038 it_cfg_status_t
iscsit_config_merge_ini(it_config_t * cfg)2039 iscsit_config_merge_ini(it_config_t *cfg)
2040 {
2041 	iscsit_ini_t	*ini, *next_ini;
2042 	it_ini_t	*cfg_ini;
2043 
2044 	/*
2045 	 * Initiator objects are so simple we will just destroy all the current
2046 	 * objects and build new ones.  Nothing should ever reference an
2047 	 * initator object.. instead just lookup the initiator object and
2048 	 * grab the properties while holding the global config lock.
2049 	 */
2050 	for (ini = avl_first(&iscsit_global.global_ini_list);
2051 	    ini != NULL;
2052 	    ini = next_ini) {
2053 		next_ini = AVL_NEXT(&iscsit_global.global_ini_list, ini);
2054 		avl_remove(&iscsit_global.global_ini_list, ini);
2055 		nvlist_free(ini->ini_props);
2056 		kmem_free(ini, sizeof (*ini));
2057 		iscsit_global_rele();
2058 	}
2059 
2060 	for (cfg_ini = cfg->config_ini_list;
2061 	    cfg_ini != NULL;
2062 	    cfg_ini = cfg_ini->ini_next) {
2063 		ini = kmem_zalloc(sizeof (iscsit_ini_t), KM_SLEEP);
2064 		(void) strlcpy(ini->ini_name, cfg_ini->ini_name,
2065 		    MAX_ISCSI_NODENAMELEN);
2066 		(void) nvlist_dup(cfg_ini->ini_properties, &ini->ini_props,
2067 		    KM_SLEEP);
2068 		avl_add(&iscsit_global.global_ini_list, ini);
2069 		iscsit_global_hold();
2070 	}
2071 
2072 	return (ITCFG_SUCCESS);
2073 }
2074 
2075 int
iscsit_ini_avl_compare(const void * void_ini1,const void * void_ini2)2076 iscsit_ini_avl_compare(const void *void_ini1, const void *void_ini2)
2077 {
2078 	const iscsit_ini_t	*ini1 = void_ini1;
2079 	const iscsit_ini_t	*ini2 = void_ini2;
2080 	int			result;
2081 
2082 	/*
2083 	 * Sort by ISID first then TSIH
2084 	 */
2085 	result = strcmp(ini1->ini_name, ini2->ini_name);
2086 	if (result < 0) {
2087 		return (-1);
2088 	} else if (result > 0) {
2089 		return (1);
2090 	}
2091 
2092 	return (0);
2093 }
2094 
2095 iscsit_ini_t *
iscsit_ini_lookup_locked(char * ini_name)2096 iscsit_ini_lookup_locked(char *ini_name)
2097 {
2098 	iscsit_ini_t	tmp_ini;
2099 	iscsit_ini_t	*result;
2100 
2101 	/*
2102 	 * Use a dummy target for lookup, filling in all fields used in AVL
2103 	 * comparison.
2104 	 */
2105 	(void) strlcpy(tmp_ini.ini_name, ini_name, MAX_ISCSI_NODENAMELEN);
2106 	result = avl_find(&iscsit_global.global_ini_list, &tmp_ini, NULL);
2107 
2108 	return (result);
2109 }
2110