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 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <unistd.h>
31
32 #include "isns_server.h"
33 #include "isns_msgq.h"
34 #include "isns_cache.h"
35 #include "isns_cfg.h"
36 #include "isns_obj.h"
37 #include "isns_dseng.h"
38 #include "isns_log.h"
39 #include "isns_scn.h"
40 #include "isns_pdu.h"
41
42 /*
43 * global variables.
44 */
45
46 /*
47 * local variables.
48 */
49 static scn_registry_t *scn_registry = NULL;
50 static int scn_dispatched = 0;
51
52 /*
53 * external variables.
54 */
55 extern uint8_t mgmt_scn;
56 extern msg_queue_t *sys_q;
57 extern msg_queue_t *scn_q;
58 extern const int UID_ATTR_INDEX[MAX_OBJ_TYPE_FOR_SIZE];
59
60 #ifdef DEBUG
61 extern void dump_pdu1(isns_pdu_t *);
62 #endif
63
64 static int sf_gen(scn_raw_t *);
65 static int sf_error(scn_raw_t *);
66
67 static scn_raw_t *make_raw_entity(isns_obj_t *);
68 static scn_raw_t *make_raw_iscsi(isns_obj_t *);
69 static scn_raw_t *make_raw_portal(isns_obj_t *);
70 static scn_raw_t *make_raw_assoc_iscsi(isns_obj_t *);
71 static scn_raw_t *make_raw_assoc_dd(isns_obj_t *);
72 static scn_raw_t *(*const make_raw[MAX_OBJ_TYPE_FOR_SIZE])(isns_obj_t *) = {
73 NULL,
74 &make_raw_entity,
75 &make_raw_iscsi,
76 &make_raw_portal,
77 NULL, /* OBJ_PG */
78 NULL, /* OBJ_DD */
79 NULL, /* OBJ_DDS */
80 NULL, /* MAX_OBJ_TYPE */
81 NULL, /* OBJ_DUMMY1 */
82 NULL, /* OBJ_DUMMY2 */
83 NULL, /* OBJ_DUMMY3 */
84 NULL, /* OBJ_DUMMY4 */
85 &make_raw_assoc_iscsi,
86 &make_raw_assoc_dd
87 };
88
89 static scn_text_t *scn_gen_entity(scn_raw_t *);
90 static scn_text_t *scn_gen_iscsi(scn_raw_t *);
91 static scn_text_t *scn_gen_portal(scn_raw_t *);
92 static scn_text_t *scn_gen_assoc_dd(scn_raw_t *);
93 static scn_text_t *(*const scn_gen[MAX_OBJ_TYPE_FOR_SIZE])(scn_raw_t *) = {
94 NULL,
95 &scn_gen_entity,
96 &scn_gen_iscsi,
97 &scn_gen_portal,
98 NULL, /* OBJ_PG */
99 NULL, /* OBJ_DD */
100 NULL, /* OBJ_DDS */
101 NULL, /* MAX_OBJ_TYPE */
102 NULL, /* OBJ_DUMMY1 */
103 NULL, /* OBJ_DUMMY2 */
104 NULL, /* OBJ_DUMMY3 */
105 NULL, /* OBJ_DUMMY4 */
106 &scn_gen_iscsi,
107 &scn_gen_assoc_dd
108 };
109
110 #define SCN_TEST(E, BITMAP, UID1, UID2, NT) \
111 (((E) & (BITMAP)) && \
112 (!((BITMAP) & (ISNS_INIT_SELF_INFO_ONLY | \
113 ISNS_TARGET_SELF_INFO_ONLY)) || \
114 ((UID1) == (UID2)) || \
115 (((BITMAP) & ISNS_INIT_SELF_INFO_ONLY) && \
116 ((NT) & ISNS_INITIATOR_NODE_TYPE)) || \
117 (((BITMAP) & ISNS_TARGET_SELF_INFO_ONLY) && \
118 ((NT) & ISNS_TARGET_NODE_TYPE))))
119
120 /*
121 * local functions.
122 */
123
124 /*
125 * ****************************************************************************
126 *
127 * free_portal_1:
128 * Free one SCN portal or decrease the reference count if the portal
129 * is referenced by other SCN entry(s).
130 *
131 * p - the portal.
132 *
133 * ****************************************************************************
134 */
135 static void
free_portal_1(scn_portal_t * p)136 free_portal_1(
137 scn_portal_t *p
138 )
139 {
140 if (p->ref <= 1) {
141 if (p->sz == sizeof (in6_addr_t)) {
142 free(p->ip.in6);
143 }
144 free(p);
145 } else {
146 p->ref --;
147 }
148 }
149
150 /*
151 * ****************************************************************************
152 *
153 * free_portal:
154 * Free the unused portals, which are extracted for new SCN entry,
155 * after the new SCN entry is added.
156 *
157 * p - the portal.
158 *
159 * ****************************************************************************
160 */
161 static void
free_portal(scn_portal_t * p)162 free_portal(
163 scn_portal_t *p
164 )
165 {
166 scn_portal_t *n;
167
168 while (p != NULL) {
169 n = p->next;
170 free_portal_1(p);
171 p = n;
172 }
173 }
174
175 /*
176 * ****************************************************************************
177 *
178 * free_portal_list:
179 * Free the list of portals while a SCN entry is being destroyed.
180 *
181 * l - the portal list.
182 *
183 * ****************************************************************************
184 */
185 static void
free_portal_list(scn_list_t * l)186 free_portal_list(
187 scn_list_t *l
188 )
189 {
190 scn_list_t *n;
191 scn_portal_t *p;
192
193 while (l != NULL) {
194 n = l->next;
195 p = l->data.portal;
196 free_portal_1(p);
197 free(l);
198 l = n;
199 }
200 }
201
202 /*
203 * ****************************************************************************
204 *
205 * free_scn_text:
206 * Free one SCN or decrease the ref count after the SCN is emitted.
207 *
208 * text - the SCN.
209 *
210 * ****************************************************************************
211 */
212 static void
free_scn_text(scn_text_t * text)213 free_scn_text(
214 scn_text_t *text
215 )
216 {
217 if (text->ref <= 1) {
218 free(text->iscsi);
219 free(text);
220 } else {
221 text->ref --;
222 }
223 }
224
225 /*
226 * ****************************************************************************
227 *
228 * free_scn_list:
229 * Free the the list of SCN.
230 *
231 * scn - the list.
232 *
233 * ****************************************************************************
234 */
235 static void
free_scn_list(scn_t * scn)236 free_scn_list(
237 scn_t *scn
238 )
239 {
240 scn_t *next_scn;
241 scn_list_t *list;
242 scn_list_t *next_list;
243
244 while (scn != NULL) {
245 next_scn = scn->next;
246 list = scn->data.list;
247 while (list != NULL) {
248 next_list = list->next;
249 free_scn_text(list->data.text);
250 free(list);
251 list = next_list;
252 }
253 free(scn);
254 scn = next_scn;
255 }
256 }
257
258 /*
259 * ****************************************************************************
260 *
261 * free_scn:
262 * Free all of SCNs which are dispatched to every entry.
263 *
264 * ****************************************************************************
265 */
266 static void
free_scn()267 free_scn(
268 )
269 {
270 scn_registry_t *p;
271
272 p = scn_registry;
273
274 while (p != NULL) {
275 free_scn_list(p->scn);
276 p->scn = NULL;
277 p = p->next;
278 }
279 }
280
281 /*
282 * ****************************************************************************
283 *
284 * free_entry:
285 * Free one SCN entry.
286 *
287 * e - the SCN entry.
288 *
289 * ****************************************************************************
290 */
291 static void
free_entry(scn_registry_t * e)292 free_entry(
293 scn_registry_t *e
294 )
295 {
296 free_scn_list(e->scn);
297 free_portal_list(e->portal.l);
298 free(e->name);
299 free(e);
300 }
301
302 /*
303 * ****************************************************************************
304 *
305 * free_raw:
306 * Free the raw data after the SCN is generated from it.
307 *
308 * raw - the raw SCN data.
309 *
310 * ****************************************************************************
311 */
312 static void
free_raw(scn_raw_t * raw)313 free_raw(
314 scn_raw_t *raw
315 )
316 {
317 if (raw->ref == 0) {
318 free(raw->iscsi);
319 }
320 if (raw->ip != NULL) {
321 free(raw->ip);
322 }
323 free(raw);
324 }
325
326 /*
327 * ****************************************************************************
328 *
329 * scn_add_portal:
330 * Add portals to the portal list of a SCN entry.
331 *
332 * e - the SCN entry.
333 * p - the portals.
334 * return - 0: successful, otherwise failed.
335 *
336 * ****************************************************************************
337 */
338 static int
scn_add_portal(scn_registry_t * e,scn_portal_t * p)339 scn_add_portal(
340 scn_registry_t *e,
341 scn_portal_t *p
342 )
343 {
344 scn_portal_t *x;
345 scn_list_t *l, *m;
346
347 scn_list_t **lp;
348
349 int found_it;
350
351 lp = &e->portal.l;
352 while (p != NULL) {
353 m = (scn_list_t *)malloc(sizeof (scn_list_t));
354 if (m == NULL) {
355 return (1);
356 }
357 found_it = 0;
358 e = scn_registry;
359 while (e && !found_it) {
360 l = e->portal.l;
361 while (l && !found_it) {
362 x = l->data.portal;
363 if (x->uid == p->uid) {
364 found_it = 1;
365 }
366 l = l->next;
367 }
368 e = e->next;
369 }
370
371 if (!found_it) {
372 x = p;
373 }
374 m->data.portal = x;
375 x->ref ++;
376 m->next = *lp;
377 *lp = m;
378
379 p = p->next;
380 }
381
382 return (0);
383 }
384
385 /*
386 * ****************************************************************************
387 *
388 * scn_remove_portal:
389 * Remove a portal from the portal list of every SCN entry.
390 *
391 * uid - the portal object uid.
392 * return - always successful (0).
393 *
394 * ****************************************************************************
395 */
396 static int
scn_remove_portal(uint32_t uid)397 scn_remove_portal(
398 uint32_t uid
399 )
400 {
401 scn_registry_t **ep, *e;
402
403 scn_portal_t *x;
404 scn_list_t **lp, *l;
405
406 ep = &scn_registry;
407 e = *ep;
408
409 while (e != NULL) {
410 lp = &e->portal.l;
411 l = *lp;
412 while (l != NULL) {
413 x = l->data.portal;
414 if (x->uid == uid) {
415 /* remove it */
416 *lp = l->next;
417 free_portal_1(x);
418 free(l);
419 } else {
420 lp = &l->next;
421 }
422 l = *lp;
423 }
424
425 if (e->portal.l == NULL) {
426 /* no portal for this entry, destroy it */
427 *ep = e->next;
428 free_entry(e);
429 } else {
430 ep = &e->next;
431 }
432 e = *ep;
433 }
434
435 return (0);
436 }
437
438 /*
439 * ****************************************************************************
440 *
441 * scn_list_add:
442 * Add one SCN entry to the SCN entry list.
443 *
444 * e - the SCN entry.
445 * return - always successful (0).
446 *
447 * ****************************************************************************
448 */
449 static int
scn_list_add(scn_registry_t * e)450 scn_list_add(
451 scn_registry_t *e
452 )
453 {
454 scn_registry_t **pp;
455 scn_portal_t *p;
456
457 p = e->portal.p;
458 e->portal.l = NULL;
459
460 pp = &scn_registry;
461 while (*pp) {
462 if ((*pp)->uid == e->uid) {
463 /* replace the bitmap */
464 (*pp)->bitmap = e->bitmap;
465 free_portal(p);
466 free_entry(e);
467 return (0);
468 } else if ((*pp)->uid < e->uid) {
469 break;
470 }
471 pp = &(*pp)->next;
472 }
473
474 (void) scn_add_portal(e, p);
475
476 if (e->portal.l != NULL || sys_q == NULL) {
477 /* insert it to the list */
478 e->next = *pp;
479 *pp = e;
480 } else {
481 /* no portal, ignore it */
482 free_entry(e);
483 }
484
485 /* free the unused portal(s) */
486 free_portal(p);
487
488 return (0);
489 }
490
491 /*
492 * ****************************************************************************
493 *
494 * scn_list_remove:
495 * Remove one SCN entry from the SCN entry list.
496 *
497 * uid - the SCN entry unique ID.
498 * return - always successful (0).
499 *
500 * ****************************************************************************
501 */
502 static int
scn_list_remove(uint32_t uid)503 scn_list_remove(
504 uint32_t uid
505 )
506 {
507 scn_registry_t **ep, *e;
508
509 ep = &scn_registry;
510 e = *ep;
511 while (e) {
512 if (e->uid == uid) {
513 /* destroy it */
514 *ep = e->next;
515 free_entry(e);
516 break;
517 } else if (e->uid < uid) {
518 break;
519 }
520 ep = &e->next;
521 e = *ep;
522 }
523
524 return (0);
525 }
526
527 /*
528 * ****************************************************************************
529 *
530 * cb_get_scn_port:
531 * The callback function which returns the SCN port of a portal object.
532 *
533 * p1 - the portal object.
534 * p2 - the lookup control data.
535 * return - the SCN port number.
536 *
537 * ****************************************************************************
538 */
539 static int
cb_get_scn_port(void * p1,void * p2)540 cb_get_scn_port(
541 void *p1,
542 /*ARGSUSED*/
543 void *p2
544 )
545 {
546 isns_obj_t *obj = (isns_obj_t *)p1;
547
548 isns_attr_t *attr = &obj->attrs[
549 ATTR_INDEX_PORTAL(ISNS_SCN_PORT_ATTR_ID)];
550
551 int port = 0;
552
553 if (attr->tag != 0 && attr->value.ui != 0) {
554 port = (int)attr->value.ui;
555 }
556
557 return (port);
558 }
559
560 /*
561 * ****************************************************************************
562 *
563 * new_scn_portal:
564 * Make a new SCN portal.
565 *
566 * ref - the ref count.
567 * uid - the portal object UID.
568 * ip - the ip address.
569 * port - the port number.
570 * return - the SCN portal.
571 *
572 * ****************************************************************************
573 */
574 static scn_portal_t *
new_scn_portal(uint32_t ref,uint32_t uid,in6_addr_t * ip,uint32_t port)575 new_scn_portal(
576 uint32_t ref,
577 uint32_t uid,
578 in6_addr_t *ip,
579 uint32_t port
580 )
581 {
582 scn_portal_t *p;
583
584 p = (scn_portal_t *)malloc(sizeof (scn_portal_t));
585 if (p != NULL) {
586 p->uid = uid;
587 /* convert the ipv6 to ipv4 */
588 if (((int *)ip)[0] == 0x00 &&
589 ((int *)ip)[1] == 0x00 &&
590 ((uchar_t *)ip)[8] == 0x00 &&
591 ((uchar_t *)ip)[9] == 0x00 &&
592 ((uchar_t *)ip)[10] == 0xFF &&
593 ((uchar_t *)ip)[11] == 0xFF) {
594 p->sz = sizeof (in_addr_t);
595 p->ip.in = ((uint32_t *)ip)[3];
596 free(ip);
597 } else {
598 p->sz = sizeof (in6_addr_t);
599 p->ip.in6 = ip;
600 }
601 p->port = port;
602 p->ref = ref;
603 p->so = 0;
604 p->next = NULL;
605 }
606
607 return (p);
608 }
609
610 /*
611 * ****************************************************************************
612 *
613 * extract scn_portal:
614 * Extract the SCN portal(s) for a storage node.
615 *
616 * name - the storage node name.
617 * return - the SCN portal list.
618 *
619 * ****************************************************************************
620 */
621 static scn_portal_t *
extract_scn_portal(uchar_t * name)622 extract_scn_portal(
623 uchar_t *name
624 )
625 {
626 scn_portal_t *list = NULL;
627 scn_portal_t *p;
628
629 lookup_ctrl_t lc_pg, lc_p;
630 uint32_t pg_uid, uid;
631
632 in6_addr_t *ip;
633 uint32_t port;
634
635 lc_pg.type = OBJ_PG;
636 lc_pg.curr_uid = 0;
637 lc_pg.id[0] = ATTR_INDEX_PG(ISNS_PG_ISCSI_NAME_ATTR_ID);
638 lc_pg.op[0] = OP_STRING;
639 lc_pg.data[0].ptr = name;
640 lc_pg.op[1] = 0;
641
642 lc_pg.id[1] = ISNS_PG_PORTAL_IP_ADDR_ATTR_ID;
643 lc_pg.id[2] = ISNS_PG_PORTAL_PORT_ATTR_ID;
644
645 lc_p.type = OBJ_PORTAL;
646 lc_p.curr_uid = 0;
647 lc_p.id[0] = ATTR_INDEX_PORTAL(ISNS_PORTAL_IP_ADDR_ATTR_ID);
648 lc_p.op[0] = OP_MEMORY_IP6;
649 lc_p.id[1] = ATTR_INDEX_PORTAL(ISNS_PORTAL_PORT_ATTR_ID);
650 lc_p.op[1] = OP_INTEGER;
651 lc_p.op[2] = 0;
652
653 while (cache_lookup(&lc_pg, &pg_uid, cb_clone_attrs) == 0 &&
654 pg_uid != 0) {
655 ip = lc_pg.data[1].ip;
656 port = lc_pg.data[2].ui;
657 if (ip != NULL) {
658 lc_p.data[0].ip = ip;
659 lc_p.data[1].ui = port;
660 port = cache_lookup(&lc_p, &uid, cb_get_scn_port);
661 if (port != 0 && uid != 0) {
662 /* ref starts from 1 */
663 p = new_scn_portal(1, uid, ip, port);
664 if (p != NULL) {
665 p->next = list;
666 list = p;
667 } else {
668 free(ip);
669 free(p);
670 }
671 } else {
672 /* portal not registered or no scn port */
673 free(ip);
674 }
675 }
676 lc_pg.curr_uid = pg_uid;
677 }
678
679 return (list);
680 }
681
682 /*
683 * ****************************************************************************
684 *
685 * cb_update_scn_bitmap:
686 * The callback function which updates the SCN Bitmap attribute of
687 * a storage node object.
688 *
689 * p1 - the storage node object.
690 * p2 - the lookup control data.
691 * return - error code.
692 *
693 * ****************************************************************************
694 */
695 static int
cb_update_scn_bitmap(void * p1,void * p2)696 cb_update_scn_bitmap(
697 void *p1,
698 void *p2
699 )
700 {
701 int ec = 0;
702
703 isns_obj_t *obj = (isns_obj_t *)p1;
704 lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
705
706 int id = ATTR_INDEX_ISCSI(ISNS_ISCSI_SCN_BITMAP_ATTR_ID);
707 isns_attr_t *attr = &obj->attrs[id];
708
709 uint32_t bitmap = lcp->data[2].ui;
710
711 if (bitmap != 0) {
712 attr->tag = ISNS_ISCSI_SCN_BITMAP_ATTR_ID;
713 attr->len = 4;
714 } else if (attr->tag == 0) {
715 return (ec);
716 } else {
717 attr->tag = 0;
718 attr->len = 0;
719 }
720 attr->value.ui = bitmap;
721
722 if (sys_q != NULL) {
723 ec = write_data(DATA_UPDATE, obj);
724 }
725
726 return (ec);
727 }
728
729 /*
730 * ****************************************************************************
731 *
732 * cb_get_node_type:
733 * The callback function which returns the node type attribute of
734 * a storage node object.
735 *
736 * p1 - the storage node object.
737 * p2 - the lookup control data.
738 * return - error code.
739 *
740 * ****************************************************************************
741 */
742 static int
cb_get_node_type(void * p1,void * p2)743 cb_get_node_type(
744 void *p1,
745 /* LINTED E_FUNC_ARG_UNUSED */
746 void *p2
747 )
748 {
749 isns_obj_t *obj = (isns_obj_t *)p1;
750 isns_attr_t *attr = &obj->attrs[
751 ATTR_INDEX_ISCSI(ISNS_ISCSI_NODE_TYPE_ATTR_ID)];
752 int nt = (int)attr->value.ui;
753
754 return (nt);
755 }
756
757 /*
758 * ****************************************************************************
759 *
760 * cb_get_node_type:
761 * The callback function which returns the storage node object UID
762 * from a portal group object.
763 *
764 * p1 - the pg object.
765 * p2 - the lookup control data.
766 * return - the storage node object UID.
767 *
768 * ****************************************************************************
769 */
770 static int
cb_pg_node(void * p1,void * p2)771 cb_pg_node(
772 void *p1,
773 /* LINTED E_FUNC_ARG_UNUSED */
774 void *p2
775 )
776 {
777 uint32_t ref;
778
779 ref = get_ref_t(p1, OBJ_ISCSI);
780
781 return ((int)ref);
782 }
783
784 /*
785 * ****************************************************************************
786 *
787 * make_raw_entity:
788 * Make raw SCN data with a Network Entity object.
789 *
790 * obj - the network entity object.
791 * return - the raw SCN data.
792 *
793 * ****************************************************************************
794 */
795 static scn_raw_t *
make_raw_entity(isns_obj_t * obj)796 make_raw_entity(
797 /*ARGSUSED*/
798 isns_obj_t *obj
799 )
800 {
801 scn_raw_t *raw;
802
803 raw = (scn_raw_t *)malloc(sizeof (scn_raw_t));
804 if (raw != NULL) {
805 raw->type = obj->type;
806 raw->uid = get_obj_uid(obj);
807 raw->iscsi = NULL;
808 raw->ref = 0;
809 raw->ilen = 0;
810 raw->nt = 0;
811 raw->ip = NULL;
812 raw->dd_id = 0;
813 raw->dds_id = 0;
814 } else {
815 isnslog(LOG_DEBUG, "make_raw_entity", "malloc failed.");
816 }
817
818 return (raw);
819 }
820
821 /*
822 * ****************************************************************************
823 *
824 * make_raw_iscsi:
825 * Make raw SCN data with a Storage Node object.
826 *
827 * obj - the storage node object.
828 * return - the raw SCN data.
829 *
830 * ****************************************************************************
831 */
832 static scn_raw_t *
make_raw_iscsi(isns_obj_t * obj)833 make_raw_iscsi(
834 isns_obj_t *obj
835 )
836 {
837 uint32_t uid;
838 uint32_t nt;
839 uchar_t *iscsi;
840 uint32_t ilen;
841
842 isns_attr_t *attr;
843
844 scn_raw_t *raw;
845
846 uid = get_obj_uid(obj);
847 attr = &obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NODE_TYPE_ATTR_ID)];
848 nt = attr->value.ui;
849 attr = &obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID)];
850
851 raw = (scn_raw_t *)malloc(sizeof (scn_raw_t));
852 ilen = attr->len;
853 iscsi = (uchar_t *)malloc(ilen);
854 if (raw != NULL && iscsi != NULL) {
855 /* copy the iscsi storage node name */
856 (void) strcpy((char *)iscsi, (char *)attr->value.ptr);
857
858 raw->type = obj->type;
859 raw->uid = uid;
860 raw->iscsi = iscsi;
861 raw->ref = 0;
862 raw->ilen = ilen;
863 raw->nt = nt;
864 raw->ip = NULL;
865 raw->dd_id = 0;
866 raw->dds_id = 0;
867 } else {
868 free(raw);
869 free(iscsi);
870 raw = NULL;
871 isnslog(LOG_DEBUG, "make_raw_iscsi", "malloc failed.");
872 }
873
874 return (raw);
875 }
876
877 /*
878 * ****************************************************************************
879 *
880 * make_raw_portal:
881 * Make raw SCN data with a Portal object.
882 *
883 * obj - the portal object.
884 * return - the raw SCN data.
885 *
886 * ****************************************************************************
887 */
888 static scn_raw_t *
make_raw_portal(isns_obj_t * obj)889 make_raw_portal(
890 isns_obj_t *obj
891 )
892 {
893 isns_attr_t *attr;
894 in6_addr_t *ip;
895 uint32_t port;
896
897 scn_raw_t *raw;
898
899 raw = (scn_raw_t *)malloc(sizeof (scn_raw_t));
900 ip = (in6_addr_t *)malloc(sizeof (in6_addr_t));
901 if (raw != NULL && ip != NULL) {
902 attr = &obj->attrs[
903 ATTR_INDEX_PORTAL(ISNS_PORTAL_IP_ADDR_ATTR_ID)];
904 (void) memcpy(ip, attr->value.ip, sizeof (in6_addr_t));
905 attr = &obj->attrs[
906 ATTR_INDEX_PORTAL(ISNS_PORTAL_PORT_ATTR_ID)];
907 port = attr->value.ui;
908
909 raw->type = obj->type;
910 raw->uid = 0;
911 raw->iscsi = NULL;
912 raw->ref = 0;
913 raw->ilen = 0;
914 raw->nt = 0;
915 raw->ip = ip;
916 raw->port = port;
917 raw->dd_id = 0;
918 raw->dds_id = 0;
919 } else {
920 free(ip);
921 free(raw);
922 raw = NULL;
923 isnslog(LOG_DEBUG, "make_raw_portal", "malloc failed.");
924 }
925
926 return (raw);
927 }
928
929 /*
930 * ****************************************************************************
931 *
932 * make_raw_assoc_iscsi:
933 * Make raw SCN data with a Discovery Domain member association.
934 *
935 * obj - the member association object.
936 * return - the raw SCN data.
937 *
938 * ****************************************************************************
939 */
940 static scn_raw_t *
make_raw_assoc_iscsi(isns_obj_t * obj)941 make_raw_assoc_iscsi(
942 isns_obj_t *obj
943 )
944 {
945 uint32_t uid;
946 uint32_t dd_id;
947 uint32_t nt;
948
949 lookup_ctrl_t lc;
950 isns_attr_t *attr;
951
952 scn_raw_t *raw;
953 uchar_t *iscsi;
954 uint32_t ilen;
955
956 uid = get_obj_uid(obj);
957 dd_id = get_parent_uid(obj);
958
959 SET_UID_LCP(&lc, OBJ_ISCSI, uid);
960
961 nt = cache_lookup(&lc, NULL, cb_get_node_type);
962
963 attr = &obj->attrs[ATTR_INDEX_ASSOC_ISCSI(ISNS_DD_ISCSI_NAME_ATTR_ID)];
964
965 raw = (scn_raw_t *)malloc(sizeof (scn_raw_t));
966 ilen = attr->len;
967 iscsi = (uchar_t *)malloc(ilen);
968 if (raw != NULL && iscsi != NULL) {
969 /* copy the iscsi storage node name */
970 (void) strcpy((char *)iscsi, (char *)attr->value.ptr);
971
972 raw->type = obj->type;
973 raw->uid = uid;
974 raw->iscsi = iscsi;
975 raw->ref = 0;
976 raw->ilen = ilen;
977 raw->nt = nt;
978 raw->ip = NULL;
979 raw->dd_id = dd_id;
980 raw->dds_id = 0;
981 } else {
982 free(raw);
983 free(iscsi);
984 raw = NULL;
985 isnslog(LOG_DEBUG, "make_raw_assoc_iscsi", "malloc failed.");
986 }
987
988 return (raw);
989 }
990
991 /*
992 * ****************************************************************************
993 *
994 * make_raw_assoc_dd:
995 * Make raw SCN data with a Discovery Domain Set member association.
996 *
997 * obj - the member association object.
998 * return - the raw SCN data.
999 *
1000 * ****************************************************************************
1001 */
1002 static scn_raw_t *
make_raw_assoc_dd(isns_obj_t * obj)1003 make_raw_assoc_dd(
1004 isns_obj_t *obj
1005 )
1006 {
1007 scn_raw_t *raw;
1008
1009 raw = (scn_raw_t *)malloc(sizeof (scn_raw_t));
1010 if (raw != NULL) {
1011 raw->type = obj->type;
1012 raw->uid = 0;
1013 raw->iscsi = NULL;
1014 raw->ref = 0;
1015 raw->ilen = 0;
1016 raw->nt = 0;
1017 raw->ip = NULL;
1018 raw->dd_id = get_obj_uid(obj);
1019 raw->dds_id = get_parent_uid(obj);
1020 } else {
1021 isnslog(LOG_DEBUG, "make_raw_assoc_dd", "malloc failed.");
1022 }
1023
1024 return (raw);
1025 }
1026
1027 /*
1028 * ****************************************************************************
1029 *
1030 * scn_gen_entity:
1031 * Generate SCN with the raw SCN data from a Network Entity object.
1032 *
1033 * raw - the raw SCN data.
1034 * return - the SCN.
1035 *
1036 * ****************************************************************************
1037 */
1038 static scn_text_t *
scn_gen_entity(scn_raw_t * raw)1039 scn_gen_entity(
1040 /* LINTED E_FUNC_ARG_UNUSED */
1041 scn_raw_t *raw
1042 )
1043 {
1044 return (NULL);
1045 }
1046
1047 /*
1048 * ****************************************************************************
1049 *
1050 * scn_gen_iscsi:
1051 * Generate SCN with the raw SCN data from a Storage Node object.
1052 *
1053 * raw - the raw SCN data.
1054 * return - the SCN.
1055 *
1056 * ****************************************************************************
1057 */
1058 static scn_text_t *
scn_gen_iscsi(scn_raw_t * raw)1059 scn_gen_iscsi(
1060 scn_raw_t *raw
1061 )
1062 {
1063 scn_text_t *text;
1064
1065 text = (scn_text_t *)malloc(sizeof (scn_text_t));
1066 if (text != NULL) {
1067 text->flag = 0;
1068 text->ref = 1; /* start with 1 */
1069 text->uid = raw->uid;
1070 text->iscsi = raw->iscsi;
1071 raw->ref ++;
1072 text->ilen = raw->ilen;
1073 text->nt = raw->nt;
1074 text->dd_id = raw->dd_id;
1075 text->dds_id = raw->dds_id;
1076 text->next = NULL;
1077 } else {
1078 isnslog(LOG_DEBUG, "scn_gen_iscsi", "malloc failed.");
1079 }
1080 return (text);
1081 }
1082
1083 /*
1084 * ****************************************************************************
1085 *
1086 * scn_gen_portal:
1087 * Generate SCN with the raw SCN data from a Portal object.
1088 *
1089 * raw - the raw SCN data.
1090 * return - the SCN.
1091 *
1092 * ****************************************************************************
1093 */
1094 static scn_text_t *
scn_gen_portal(scn_raw_t * raw)1095 scn_gen_portal(
1096 scn_raw_t *raw
1097 )
1098 {
1099 in6_addr_t *ip;
1100 uint32_t port;
1101
1102 uint32_t pg_uid, uid;
1103 lookup_ctrl_t pg_lc, lc;
1104
1105 uint32_t nt;
1106 uchar_t *name;
1107 int ilen;
1108
1109 scn_text_t *text, *l = NULL;
1110
1111 ip = raw->ip;
1112 port = raw->port;
1113
1114 pg_lc.curr_uid = 0;
1115 pg_lc.type = OBJ_PG;
1116 pg_lc.id[0] = ATTR_INDEX_PG(ISNS_PG_PORTAL_IP_ADDR_ATTR_ID);
1117 pg_lc.op[0] = OP_MEMORY_IP6;
1118 pg_lc.data[0].ip = ip;
1119 pg_lc.id[1] = ATTR_INDEX_PG(ISNS_PG_PORTAL_PORT_ATTR_ID);
1120 pg_lc.op[1] = OP_INTEGER;
1121 pg_lc.data[1].ui = port;
1122 pg_lc.op[2] = 0;
1123
1124 SET_UID_LCP(&lc, OBJ_ISCSI, 0);
1125
1126 lc.id[1] = ISNS_ISCSI_NAME_ATTR_ID;
1127 lc.id[2] = ISNS_ISCSI_NODE_TYPE_ATTR_ID;
1128 lc.data[1].ptr = NULL;
1129
1130 /* get a pg which is associated to the portal */
1131 uid = cache_lookup(&pg_lc, &pg_uid, cb_pg_node);
1132 while (pg_uid != 0) {
1133 if (uid != 0) {
1134 lc.data[0].ui = uid;
1135 (void) cache_lookup(&lc, NULL, cb_clone_attrs);
1136 name = lc.data[1].ptr;
1137 if (name != NULL) {
1138 nt = lc.data[2].ui;
1139 text = (scn_text_t *)malloc(
1140 sizeof (scn_text_t));
1141 if (text != NULL) {
1142 text->flag = 0;
1143 text->ref = 1; /* start with 1 */
1144 text->uid = uid;
1145 text->iscsi = name;
1146 ilen = strlen((char *)name);
1147 ilen += 4 - (ilen % 4);
1148 text->ilen = ilen;
1149 text->nt = nt;
1150 text->dd_id = 0;
1151 text->dds_id = 0;
1152 text->next = l;
1153 l = text;
1154 } else {
1155 free(name);
1156 isnslog(LOG_DEBUG, "scn_gen_portal",
1157 "malloc failed.");
1158 }
1159 lc.data[1].ptr = NULL;
1160 } else {
1161 isnslog(LOG_WARNING, "scn_gen_portal",
1162 "cannot get node name.");
1163 }
1164 }
1165
1166 /* get the next pg */
1167 pg_lc.curr_uid = pg_uid;
1168 uid = cache_lookup(&pg_lc, &pg_uid, cb_pg_node);
1169 }
1170
1171 /* update the iscsi storage node object */
1172 raw->event = ISNS_OBJECT_UPDATED;
1173
1174 return (l);
1175 }
1176
1177 /*
1178 * ****************************************************************************
1179 *
1180 * scn_gen_assoc_dd:
1181 * Generate SCN with the raw SCN data from a DD membership object.
1182 *
1183 * raw - the raw SCN data.
1184 * return - the SCN.
1185 *
1186 * ****************************************************************************
1187 */
1188 static scn_text_t *
scn_gen_assoc_dd(scn_raw_t * raw)1189 scn_gen_assoc_dd(
1190 /* LINTED E_FUNC_ARG_UNUSED */
1191 scn_raw_t *raw
1192 )
1193 {
1194 return (NULL);
1195 }
1196
1197 /*
1198 * ****************************************************************************
1199 *
1200 * make_scn:
1201 * Make a SCN with an event and an object.
1202 *
1203 * event - the event.
1204 * obj - the object.
1205 * return - always successful (0).
1206 *
1207 * ****************************************************************************
1208 */
1209 int
make_scn(uint32_t event,isns_obj_t * obj)1210 make_scn(
1211 uint32_t event,
1212 isns_obj_t *obj
1213 )
1214 {
1215 scn_raw_t *raw = NULL;
1216
1217 scn_raw_t *(*f)(isns_obj_t *) = make_raw[obj->type];
1218
1219 if (f != NULL) {
1220 /* make raw scn data */
1221 raw = f(obj);
1222 }
1223 if (raw != NULL) {
1224 /* trigger an scn event */
1225 raw->event = event;
1226 (void) queue_msg_set(scn_q, SCN_SET, (void *)raw);
1227 }
1228
1229 return (0);
1230 }
1231
1232 /*
1233 * data structure of the SCN state transition table.
1234 */
1235 typedef struct scn_tbl {
1236 int state;
1237 uint32_t event;
1238 isns_type_t type;
1239 int (*sf)(scn_raw_t *);
1240 int next_state;
1241 } scn_tbl_t;
1242
1243 /*
1244 * the SCN state transition table.
1245 */
1246 static const scn_tbl_t stbl[] = {
1247 { -1, 0, OBJ_PG, NULL, 0 },
1248 { -1, 0, OBJ_DD, NULL, 0 },
1249 { -1, 0, OBJ_DDS, NULL, 0 },
1250
1251 { 0, ISNS_OBJECT_ADDED, OBJ_ENTITY, NULL, 1 },
1252 { 1, ISNS_OBJECT_ADDED, OBJ_ISCSI, sf_gen, 1 },
1253 { 1, ISNS_OBJECT_ADDED, 0, NULL, 1 },
1254
1255 { 0, ISNS_OBJECT_UPDATED, OBJ_ENTITY, sf_gen, 2 },
1256 { 2, ISNS_OBJECT_UPDATED, 0, NULL, 2 },
1257 { 2, ISNS_OBJECT_ADDED, OBJ_ISCSI, sf_gen, 2 },
1258 { 2, ISNS_OBJECT_ADDED, 0, NULL, 2 },
1259
1260 { 0, ISNS_OBJECT_REMOVED, OBJ_ENTITY, NULL, 3 },
1261 { 0, ISNS_OBJECT_REMOVED, 0, sf_gen, 4 },
1262 { 3, ISNS_OBJECT_REMOVED, OBJ_ISCSI, sf_gen, 3 },
1263 { 3, ISNS_OBJECT_REMOVED, 0, NULL, 3 },
1264 { 4, ISNS_OBJECT_REMOVED, 0, sf_gen, 4 },
1265
1266 { 0, ISNS_MEMBER_ADDED, OBJ_ASSOC_ISCSI, sf_gen, 5 },
1267 { 5, ISNS_MEMBER_ADDED, OBJ_ASSOC_ISCSI, sf_gen, 5 },
1268
1269 { 0, ISNS_MEMBER_ADDED, OBJ_ASSOC_DD, sf_gen, 6 },
1270 { 6, ISNS_MEMBER_ADDED, OBJ_ASSOC_DD, sf_gen, 6 },
1271
1272 { 0, ISNS_MEMBER_REMOVED, OBJ_ASSOC_ISCSI, sf_gen, 7 },
1273 { 7, ISNS_MEMBER_REMOVED, OBJ_ASSOC_ISCSI, sf_gen, 7 },
1274
1275 { 0, ISNS_MEMBER_REMOVED, OBJ_ASSOC_DD, sf_gen, 8 },
1276 { 8, ISNS_MEMBER_REMOVED, OBJ_ASSOC_DD, sf_gen, 8 },
1277
1278 { -1, 0, 0, sf_error, -1 }
1279 };
1280
1281 /*
1282 * ****************************************************************************
1283 *
1284 * scn_disp1:
1285 * Dispatch one SCN to one SCN entry.
1286 *
1287 * event - the event.
1288 * p - the SCN entry.
1289 * t - the SCN.
1290 * return - always successful (0).
1291 *
1292 * ****************************************************************************
1293 */
1294 static int
scn_disp1(uint32_t event,scn_registry_t * p,scn_text_t * t)1295 scn_disp1(
1296 uint32_t event,
1297 scn_registry_t *p,
1298 scn_text_t *t
1299 )
1300 {
1301 scn_t *s, *r = NULL;
1302 scn_list_t *l, **lp;
1303
1304 s = p->scn;
1305
1306 while (s != NULL) {
1307 if (s->event == event) {
1308 l = s->data.list;
1309 do {
1310 if (l->data.text->uid == t->uid) {
1311 /* duplicated */
1312 return (0);
1313 }
1314 lp = &l->next;
1315 l = *lp;
1316 } while (l != NULL);
1317 break;
1318 }
1319 r = s;
1320 s = s->next;
1321 }
1322
1323 l = (scn_list_t *)malloc(sizeof (scn_list_t));
1324 if (l != NULL) {
1325 if (s == NULL) {
1326 s = (scn_t *)malloc(sizeof (scn_t));
1327 if (s != NULL) {
1328 s->event = event;
1329 s->next = NULL;
1330 if (r != NULL) {
1331 r->next = s;
1332 } else {
1333 p->scn = s;
1334 }
1335 lp = &s->data.list;
1336 } else {
1337 free(l);
1338 isnslog(LOG_DEBUG, "scn_disp1",
1339 "malloc scn failed.\n");
1340 return (0);
1341 }
1342 }
1343
1344 t->ref ++;
1345 l->data.text = t;
1346 l->next = NULL;
1347 *lp = l;
1348 } else {
1349 isnslog(LOG_DEBUG, "scn_disp1",
1350 "malloc list failed.\n");
1351 }
1352
1353 return (0);
1354 }
1355
1356 /*
1357 * ****************************************************************************
1358 *
1359 * scn_disp1:
1360 * Dispatch one SCN to every SCN entry and update the dispatch status.
1361 *
1362 * event - the event.
1363 * text - the SCN.
1364 * return - always successful (0).
1365 *
1366 * ****************************************************************************
1367 */
1368 static int
scn_disp(uint32_t event,scn_text_t * text)1369 scn_disp(
1370 uint32_t event,
1371 scn_text_t *text
1372 )
1373 {
1374 scn_registry_t *registry, *p;
1375 uint32_t dd_id = 0;
1376
1377 scn_text_t *t;
1378
1379 uint32_t e;
1380
1381 registry = scn_registry;
1382
1383 t = text;
1384 while (t != NULL) {
1385 e = event;
1386 if (t->flag == 0) {
1387 if (e & ISNS_MEMBER_ADDED) {
1388 e |= ISNS_OBJECT_ADDED;
1389 } else if (e & ISNS_MEMBER_REMOVED) {
1390 e |= ISNS_OBJECT_REMOVED;
1391 }
1392 }
1393 p = registry;
1394 while (p != NULL) {
1395 if (SCN_TEST(e, p->bitmap, p->uid, t->uid, t->nt)) {
1396 if (p->bitmap & ISNS_MGMT_REG) {
1397 /* management scn are not bound */
1398 /* by discovery domain service. */
1399 dd_id = 1;
1400 } else {
1401 dd_id = 0;
1402 /* lock the cache for reading */
1403 (void) cache_lock_read();
1404 /* verify common dd */
1405 do {
1406 dd_id = get_common_dd(
1407 p->uid,
1408 t->uid,
1409 dd_id);
1410 } while (dd_id > 0 &&
1411 is_dd_active(dd_id) == 0);
1412 /* unlock the cache */
1413 (void) cache_unlock_nosync();
1414 }
1415 if (dd_id != 0) {
1416 (void) scn_disp1(e, p, t);
1417 }
1418 }
1419 p = p->next;
1420 }
1421 t = t->next;
1422 }
1423
1424 while (text != NULL) {
1425 t = text->next;
1426 /* clean up the scn text(s) which nobody cares about. */
1427 free_scn_text(text);
1428 text = t;
1429 }
1430
1431 if (dd_id != 0) {
1432 /* scn(s) are dispatched. */
1433 scn_dispatched = 1;
1434 }
1435
1436 return (0);
1437 }
1438
1439 /*
1440 * ****************************************************************************
1441 *
1442 * sf_gen:
1443 * State transition function which generates and dispatches SCN(s).
1444 *
1445 * raw - the raw SCN data.
1446 * return - always successful (0).
1447 *
1448 * ****************************************************************************
1449 */
1450 static int
sf_gen(scn_raw_t * raw)1451 sf_gen(
1452 scn_raw_t *raw
1453 )
1454 {
1455 uint32_t event;
1456
1457 scn_text_t *(*gen)(scn_raw_t *);
1458 scn_text_t *text = NULL;
1459
1460 gen = scn_gen[raw->type];
1461 if (gen != NULL) {
1462 text = gen(raw);
1463 }
1464
1465 event = raw->event;
1466 if (text != NULL) {
1467 (void) scn_disp(event, text);
1468 }
1469
1470 return (0);
1471 }
1472
1473 /*
1474 * ****************************************************************************
1475 *
1476 * sf_error:
1477 * State transition function for an error state. It free any SCN(s)
1478 * which have been generated and dispatched previously.
1479 *
1480 * raw - the raw SCN data.
1481 * return - always successful (0).
1482 *
1483 * ****************************************************************************
1484 */
1485 static int
sf_error(scn_raw_t * raw)1486 sf_error(
1487 /* LINTED E_FUNC_ARG_UNUSED */
1488 scn_raw_t *raw
1489 )
1490 {
1491 free_scn();
1492
1493 return (0);
1494 }
1495
1496 /*
1497 * ****************************************************************************
1498 *
1499 * scn_transition:
1500 * Performs the state transition when a SCN event occurs.
1501 *
1502 * state - the previous state.
1503 * raw - the raw SCN data.
1504 * return - the next state.
1505 *
1506 * ****************************************************************************
1507 */
1508 static int
scn_transition(int state,scn_raw_t * raw)1509 scn_transition(
1510 int state,
1511 scn_raw_t *raw
1512 )
1513 {
1514 uint32_t event = raw->event;
1515 isns_type_t type = raw->type;
1516
1517 int new_state = state;
1518
1519 const scn_tbl_t *tbl;
1520
1521 tbl = &stbl[0];
1522 for (;;) {
1523 if ((tbl->state == -1 || tbl->state == state) &&
1524 (tbl->event == 0 || tbl->event == event) &&
1525 (tbl->type == 0 || tbl->type == type)) {
1526 if (tbl->next_state != 0) {
1527 new_state = tbl->next_state;
1528 }
1529 if (tbl->sf != NULL) {
1530 tbl->sf(raw);
1531 }
1532 break;
1533 }
1534 tbl ++;
1535 }
1536
1537 if (new_state == -1) {
1538 isnslog(LOG_DEBUG, "scn_transition",
1539 "prev state: %d new event: 0x%x new object: %d.\n",
1540 state, event, type);
1541 new_state = 0;
1542 }
1543
1544 state = new_state;
1545
1546 return (state);
1547 }
1548
1549 /*
1550 * ****************************************************************************
1551 *
1552 * connect_to:
1553 * Create socket connection with peer network portal.
1554 *
1555 * sz - the size of the ip addr.
1556 * in - the ipv4 address.
1557 * in6 - the ipv6 address.
1558 * port2- the port info.
1559 * return - the socket descriptor.
1560 *
1561 * ****************************************************************************
1562 */
1563 int
connect_to(int sz,in_addr_t in,in6_addr_t * in6,uint32_t port2)1564 connect_to(
1565 int sz,
1566 in_addr_t in,
1567 /* LINTED E_FUNC_ARG_UNUSED */
1568 in6_addr_t *in6,
1569 uint32_t port2
1570 )
1571 {
1572 int so = -1;
1573
1574 union {
1575 struct sockaddr sin;
1576 struct sockaddr_in in;
1577 struct sockaddr_in6 in6;
1578 } ca = { 0 };
1579
1580 int tcp;
1581 uint16_t port;
1582
1583 tcp = (port2 & 0x10000) == 0 ? 1 : 0;
1584 port = (uint16_t)(port2 & 0xFFFF);
1585 if (sz == sizeof (in_addr_t)) {
1586 if (tcp != 0) {
1587 so = socket(AF_INET, SOCK_STREAM, 0);
1588 if (so != -1) {
1589 ca.in.sin_family = AF_INET;
1590 ca.in.sin_port = htons(port);
1591 ca.in.sin_addr.s_addr = in;
1592 if (connect(so, &ca.sin, sizeof (ca.in)) !=
1593 0) {
1594 isnslog(LOG_DEBUG, "connect_to",
1595 "connect() failed %%m.");
1596 (void) close(so);
1597 so = -1;
1598 }
1599 } else {
1600 isnslog(LOG_DEBUG, "connect_to",
1601 "socket() failed %%m.");
1602 }
1603 } else {
1604 /* FIXME: UDP support */
1605 isnslog(LOG_DEBUG, "connect_to", "No UDP support.");
1606 }
1607 } else {
1608 /* FIXME: IPv6 support */
1609 isnslog(LOG_DEBUG, "connect_to", "No IPv6 support.");
1610 }
1611
1612 return (so);
1613 }
1614
1615 /*
1616 * ****************************************************************************
1617 *
1618 * emit_scn:
1619 * Emit the SCN to any portal of the peer storage node.
1620 *
1621 * list - the list of portal.
1622 * pdu - the SCN packet.
1623 * pl - the SCN packet payload length.
1624 * return - always successful (0).
1625 *
1626 * ****************************************************************************
1627 */
1628 static int
emit_scn(scn_list_t * list,isns_pdu_t * pdu,size_t pl)1629 emit_scn(
1630 scn_list_t *list,
1631 isns_pdu_t *pdu,
1632 size_t pl
1633 )
1634 {
1635 int so = 0;
1636 scn_list_t *l;
1637 scn_portal_t *p;
1638
1639 isns_pdu_t *rsp = NULL;
1640 size_t rsp_sz;
1641
1642 pdu->version = htons((uint16_t)ISNSP_VERSION);
1643 pdu->func_id = htons((uint16_t)ISNS_SCN);
1644 pdu->xid = htons(get_server_xid());
1645
1646 l = list;
1647 while (l != NULL) {
1648 p = l->data.portal;
1649 so = connect_to(p->sz, p->ip.in, p->ip.in6, p->port);
1650 if (so != -1) {
1651 if (isns_send_pdu(so, pdu, pl) == 0) {
1652 /* This may help Solaris iSCSI Initiator */
1653 /* not to panic frequently. */
1654 (void) isns_rcv_pdu(so, &rsp, &rsp_sz,
1655 ISNS_RCV_SHORT_TIMEOUT);
1656 } else {
1657 isnslog(LOG_DEBUG, "emit_scn",
1658 "sending packet failed.");
1659 }
1660 (void) close(so);
1661 /* p->so = so; */
1662 break;
1663 }
1664 l = l->next;
1665 }
1666
1667 if (rsp != NULL) {
1668 #ifdef DEBUG
1669 dump_pdu1(rsp);
1670 #endif
1671 free(rsp);
1672 }
1673
1674 return (0);
1675 }
1676
1677 /*
1678 * ****************************************************************************
1679 *
1680 * scn_trigger1:
1681 * Trigger one SCN for one SCN entry.
1682 *
1683 * t - the time that SCN is being triggered.
1684 * p - the SCN entry.
1685 * return - always successful (0).
1686 *
1687 * ****************************************************************************
1688 */
1689 static int
scn_trigger1(time_t t,scn_registry_t * p)1690 scn_trigger1(
1691 time_t t,
1692 scn_registry_t *p
1693 )
1694 {
1695 int ec;
1696
1697 isns_pdu_t *pdu = NULL;
1698 size_t sz;
1699 size_t pl;
1700
1701 scn_t *s;
1702 scn_list_t *l;
1703 scn_text_t *x;
1704
1705 union {
1706 uint32_t i32;
1707 uint64_t i64;
1708 } u;
1709
1710 #ifdef DEBUG
1711 char buff[1024] = { 0 };
1712 char *logbuff = buff;
1713 #endif
1714
1715 ec = pdu_reset_scn(&pdu, &pl, &sz);
1716 if (pdu == NULL) {
1717 goto scn_done;
1718 }
1719
1720 /* add destination attribute */
1721 ec = pdu_add_tlv(&pdu, &pl, &sz,
1722 ISNS_ISCSI_NAME_ATTR_ID,
1723 p->nlen,
1724 (void *)p->name, 0);
1725 if (ec != 0) {
1726 goto scn_done;
1727 }
1728
1729 #ifdef DEBUG
1730 sprintf(logbuff, "==>%s ", p->name);
1731 logbuff += strlen(logbuff);
1732 #endif
1733
1734 /* add timestamp */
1735 u.i64 = BE_64((uint64_t)t);
1736 ec = pdu_add_tlv(&pdu, &pl, &sz,
1737 ISNS_TIMESTAMP_ATTR_ID,
1738 8,
1739 (void *)&u.i64, 1);
1740
1741 s = p->scn;
1742 while (s != NULL && ec == 0) {
1743 u.i32 = htonl(s->event);
1744 ec = pdu_add_tlv(&pdu, &pl, &sz,
1745 ISNS_ISCSI_SCN_BITMAP_ATTR_ID,
1746 4,
1747 (void *)&u.i32, 1);
1748 #ifdef DEBUG
1749 sprintf(logbuff, "EVENT [%d] ", s->event);
1750 logbuff += strlen(logbuff);
1751 #endif
1752 l = s->data.list;
1753 while (l != NULL && ec == 0) {
1754 x = l->data.text;
1755 if (x->flag == 0) {
1756 ec = pdu_add_tlv(&pdu, &pl, &sz,
1757 ISNS_ISCSI_NAME_ATTR_ID,
1758 x->ilen, (void *)x->iscsi, 0);
1759 #ifdef DEBUG
1760 sprintf(logbuff, "FROM [%s] ", x->iscsi);
1761 logbuff += strlen(logbuff);
1762 #endif
1763 if (ec == 0 &&
1764 (p->bitmap &
1765 (ISNS_MEMBER_ADDED |
1766 ISNS_MEMBER_REMOVED))) {
1767 /* management SCN */
1768 u.i32 = htonl(x->dd_id);
1769 ec = pdu_add_tlv(&pdu, &pl, &sz,
1770 ISNS_DD_ID_ATTR_ID,
1771 4, (void *)&u.i32, 1);
1772 #ifdef DEBUG
1773 sprintf(logbuff, "IN DD [%d] ",
1774 x->dd_id);
1775 logbuff += strlen(logbuff);
1776 #endif
1777 }
1778 } else {
1779 /* add(remove) dd to(from) dd-set */
1780 u.i32 = htonl(x->dd_id);
1781 ec = pdu_add_tlv(&pdu, &pl, &sz,
1782 ISNS_DD_ID_ATTR_ID,
1783 4, (void *)&u.i32, 1);
1784 u.i32 = htonl(x->dds_id);
1785 if (ec == 0) {
1786 ec = pdu_add_tlv(&pdu, &pl, &sz,
1787 ISNS_DD_ID_ATTR_ID,
1788 4, (void *)&u.i32, 1);
1789 }
1790 #ifdef DEBUG
1791 sprintf(logbuff, "FROM [%d] ", x->dd_id);
1792 logbuff += strlen(logbuff);
1793 sprintf(logbuff, "IN [%d] ", x->dds_id);
1794 logbuff += strlen(logbuff);
1795 #endif
1796 }
1797 l = l->next;
1798 }
1799 s = s->next;
1800 }
1801
1802 scn_done:
1803 if (ec == 0) {
1804 #ifdef DEBUG
1805 isnslog(LOG_DEBUG, "scn_trigger1", buff);
1806 #endif
1807 ec = emit_scn(p->portal.l, pdu, pl);
1808 } else {
1809 isnslog(LOG_DEBUG, "scn_trigger1", " failed.\n");
1810 }
1811
1812 free(pdu);
1813
1814 return (0);
1815 }
1816
1817 /*
1818 * ****************************************************************************
1819 *
1820 * scn_trigger:
1821 * Trigger one SCN for every SCN entry.
1822 *
1823 * return - always successful (0).
1824 *
1825 * ****************************************************************************
1826 */
1827 static int
scn_trigger()1828 scn_trigger(
1829 )
1830 {
1831 time_t t;
1832 scn_registry_t *p;
1833
1834 t = time(NULL);
1835
1836 p = scn_registry;
1837 while (p != NULL) {
1838 if (p->scn != NULL) {
1839 (void) scn_trigger1(t, p);
1840 }
1841 p = p->next;
1842 }
1843
1844 return (0);
1845 }
1846
1847 /*
1848 * global functions.
1849 */
1850
1851 /*
1852 * ****************************************************************************
1853 *
1854 * scn_list_load:
1855 * Load one SCN entry and add it to the SCN entry list.
1856 *
1857 * uid - the Storage Node object UID.
1858 * node - the Storage Node name.
1859 * nlen - the length of the name.
1860 * bitmap - the SCN bitmap.
1861 * return - error code.
1862 *
1863 * ****************************************************************************
1864 */
1865 int
scn_list_load(uint32_t uid,uchar_t * node,uint32_t nlen,uint32_t bitmap)1866 scn_list_load(
1867 uint32_t uid,
1868 uchar_t *node,
1869 uint32_t nlen,
1870 uint32_t bitmap
1871 )
1872 {
1873 int ec = 0;
1874
1875 scn_registry_t *list;
1876 uchar_t *name;
1877
1878 list = (scn_registry_t *)malloc(sizeof (scn_registry_t));
1879 name = (uchar_t *)malloc(nlen);
1880
1881 if (list != NULL && name != NULL) {
1882 list->uid = uid;
1883 (void) strcpy((char *)name, (char *)node);
1884 list->name = name;
1885 list->nlen = nlen;
1886 list->bitmap = bitmap;
1887 list->portal.l = NULL;
1888 list->scn = NULL;
1889 list->next = NULL;
1890 ASSERT(scn_q == NULL);
1891 (void) scn_list_add(list);
1892 } else {
1893 free(list);
1894 free(name);
1895 ec = ISNS_RSP_INTERNAL_ERROR;
1896 }
1897
1898 return (ec);
1899 }
1900
1901 /*
1902 * ****************************************************************************
1903 *
1904 * verify_scn_portal:
1905 * Extract and verify portals for every SCN entry(s) after they are
1906 * loaded from data store, for those which do not have a SCN portal,
1907 * remove it from the SCN entry list.
1908 *
1909 * return - 1: error occurs, otherwise 0.
1910 *
1911 * ****************************************************************************
1912 */
1913 int
verify_scn_portal()1914 verify_scn_portal(
1915 )
1916 {
1917 scn_registry_t **pp, *e;
1918 scn_portal_t *p;
1919
1920 pp = &scn_registry;
1921 while (*pp != NULL) {
1922 e = *pp;
1923 p = extract_scn_portal(e->name);
1924 if (p != NULL) {
1925 if (scn_add_portal(e, p) != 0) {
1926 return (1);
1927 }
1928 }
1929 if (e->portal.l != NULL) {
1930 pp = &e->next;
1931 } else {
1932 /* remove this entry */
1933 *pp = e->next;
1934 free_entry(e);
1935 }
1936 /* free the unused portal(s) */
1937 free_portal(p);
1938 }
1939
1940 return (0);
1941 }
1942
1943 /*
1944 * ****************************************************************************
1945 *
1946 * add_scn_entry:
1947 * Add a SCN entry.
1948 *
1949 * node - the Storage Node name.
1950 * nlen - the length of the name.
1951 * bitmap - the SCN bitmap.
1952 * return - error code.
1953 *
1954 * ****************************************************************************
1955 */
1956 int
add_scn_entry(uchar_t * node,uint32_t nlen,uint32_t bitmap)1957 add_scn_entry(
1958 uchar_t *node,
1959 uint32_t nlen,
1960 uint32_t bitmap
1961 )
1962 {
1963 int ec = 0;
1964
1965 uint32_t mgmt;
1966 scn_portal_t *p;
1967
1968 lookup_ctrl_t lc;
1969 uint32_t uid;
1970 scn_registry_t *e;
1971 uchar_t *name;
1972
1973 mgmt = bitmap & (
1974 ISNS_MGMT_REG |
1975 ISNS_MEMBER_REMOVED |
1976 ISNS_MEMBER_ADDED);
1977
1978 if ((mgmt > 0 &&
1979 (mgmt_scn == 0 ||
1980 mgmt < ISNS_MGMT_REG ||
1981 is_control_node(node) == 0)) ||
1982 (p = extract_scn_portal(node)) == NULL) {
1983 return (ISNS_RSP_SCN_REGIS_REJECTED);
1984 }
1985
1986 e = (scn_registry_t *)malloc(sizeof (scn_registry_t));
1987 name = (uchar_t *)malloc(nlen);
1988 if (e != NULL && name != NULL) {
1989 lc.type = OBJ_ISCSI;
1990 lc.curr_uid = 0;
1991 lc.id[0] = ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID);
1992 lc.data[0].ptr = node;
1993 lc.op[0] = OP_STRING;
1994 lc.op[1] = 0;
1995 lc.data[2].ui = bitmap;
1996 ec = cache_lookup(&lc, &uid, cb_update_scn_bitmap);
1997 if (uid == 0) {
1998 ec = ISNS_RSP_SCN_REGIS_REJECTED;
1999 }
2000 if (ec == 0) {
2001 e->uid = uid;
2002 (void) strcpy((char *)name, (char *)node);
2003 e->name = name;
2004 e->nlen = nlen;
2005 e->bitmap = bitmap;
2006 e->portal.p = p;
2007 e->scn = NULL;
2008 e->next = NULL;
2009 (void) queue_msg_set(scn_q, SCN_ADD, (void *)e);
2010 }
2011 } else {
2012 ec = ISNS_RSP_INTERNAL_ERROR;
2013 }
2014
2015 if (ec != 0) {
2016 free(e);
2017 free(name);
2018 free_portal(p);
2019 }
2020
2021 return (ec);
2022 }
2023
2024 /*
2025 * ****************************************************************************
2026 *
2027 * remove_scn_entry:
2028 * Remove a SCN entry.
2029 *
2030 * node - the Storage Node name.
2031 * return - error code.
2032 *
2033 * ****************************************************************************
2034 */
2035 int
remove_scn_entry(uchar_t * node)2036 remove_scn_entry(
2037 uchar_t *node
2038 )
2039 {
2040 int ec = 0;
2041
2042 lookup_ctrl_t lc;
2043 uint32_t uid;
2044
2045 lc.type = OBJ_ISCSI;
2046 lc.curr_uid = 0;
2047 lc.id[0] = ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID);
2048 lc.data[0].ptr = node;
2049 lc.op[0] = OP_STRING;
2050 lc.op[1] = 0;
2051 lc.data[2].ui = 0;
2052 ec = cache_lookup(&lc, &uid, cb_update_scn_bitmap);
2053 if (ec == 0 && uid != 0) {
2054 (void) queue_msg_set(scn_q, SCN_REMOVE, (void *)uid);
2055 }
2056
2057 return (ec);
2058 }
2059
2060 /*
2061 * ****************************************************************************
2062 *
2063 * remove_scn_portal:
2064 * Remove a portal from every SCN entry.
2065 *
2066 * uid - the Portal object UID.
2067 * return - alrays successful (0).
2068 *
2069 * ****************************************************************************
2070 */
2071 int
remove_scn_portal(uint32_t uid)2072 remove_scn_portal(
2073 uint32_t uid
2074 )
2075 {
2076 (void) queue_msg_set(scn_q, SCN_REMOVE_P, (void *)uid);
2077
2078 return (0);
2079 }
2080
2081 /*
2082 * ****************************************************************************
2083 *
2084 * scn_proc:
2085 * The entry point of the SCN thread. It listens on the SCN message
2086 * queue and process every SCN related stuff.
2087 *
2088 * arg - nothing.
2089 * return - NULL.
2090 *
2091 * ****************************************************************************
2092 */
2093 void *
scn_proc(void * arg)2094 scn_proc(
2095 /* LINTED E_FUNC_ARG_UNUSED */
2096 void *arg
2097 )
2098 {
2099 int state = 0;
2100
2101 scn_raw_t *raw;
2102 msg_text_t *msg;
2103
2104 for (;;) {
2105 msg = queue_msg_get(scn_q);
2106 switch (msg->id) {
2107 case SCN_ADD:
2108 (void) scn_list_add((scn_registry_t *)msg->data);
2109 break;
2110 case SCN_REMOVE:
2111 (void) scn_list_remove((uint32_t)msg->data);
2112 break;
2113 case SCN_REMOVE_P:
2114 (void) scn_remove_portal((uint32_t)msg->data);
2115 break;
2116 case SCN_SET:
2117 raw = (scn_raw_t *)msg->data;
2118 state = scn_transition(state, raw);
2119 /* free the raw data */
2120 free_raw(raw);
2121 break;
2122 case SCN_TRIGGER:
2123 if (scn_dispatched != 0) {
2124 (void) scn_trigger();
2125 }
2126 /* FALLTHROUGH */
2127 case SCN_IGNORE:
2128 /* clean the scn(s) */
2129 free_scn();
2130 /* reset the state */
2131 state = 0;
2132 /* reset the scn_dispatched flag */
2133 scn_dispatched = 0;
2134 break;
2135 case SCN_STOP:
2136 queue_msg_free(msg);
2137 return (NULL);
2138 default:
2139 break;
2140 }
2141 queue_msg_free(msg);
2142 }
2143 }
2144