emlxs_event.c (a9800beb) emlxs_event.c (8f23e9fa)
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 *
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.
8 * You can obtain a copy of the license at
9 * http://www.opensource.org/licenses/cddl1.txt.
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/*
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 2010 Emulex. All rights reserved.
23 * Copyright (c) 2004-2012 Emulex. All rights reserved.
24 * Use is subject to license terms.
25 */
26
24 * Use is subject to license terms.
25 */
26
27
28#define DEF_EVENT_STRUCT /* Needed for emlxs_events.h in emlxs_event.h */
29#include <emlxs.h>
30
31
32/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */
33EMLXS_MSG_DEF(EMLXS_EVENT_C);
34
35

--- 24 unchanged lines hidden (view full) ---

60
61} /* emlxs_event_check() */
62
63
64extern uint32_t
65emlxs_event_queue_create(emlxs_hba_t *hba)
66{
67 emlxs_event_queue_t *eventq = &EVENTQ;
27#define DEF_EVENT_STRUCT /* Needed for emlxs_events.h in emlxs_event.h */
28#include <emlxs.h>
29
30
31/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */
32EMLXS_MSG_DEF(EMLXS_EVENT_C);
33
34

--- 24 unchanged lines hidden (view full) ---

59
60} /* emlxs_event_check() */
61
62
63extern uint32_t
64emlxs_event_queue_create(emlxs_hba_t *hba)
65{
66 emlxs_event_queue_t *eventq = &EVENTQ;
68 char buf[40];
69 ddi_iblock_cookie_t iblock;
70
71 /* Clear the queue */
72 bzero(eventq, sizeof (emlxs_event_queue_t));
73
67 ddi_iblock_cookie_t iblock;
68
69 /* Clear the queue */
70 bzero(eventq, sizeof (emlxs_event_queue_t));
71
74 /* Initialize */
75 (void) sprintf(buf, "?%s%d_evt_lock control variable", DRIVER_NAME,
76 hba->ddiinst);
77 cv_init(&eventq->lock_cv, buf, CV_DRIVER, NULL);
72 cv_init(&eventq->lock_cv, NULL, CV_DRIVER, NULL);
78
73
79 (void) sprintf(buf, "?%s%d_evt_lock mutex", DRIVER_NAME, hba->ddiinst);
80
81 if (!(hba->intr_flags & EMLXS_MSI_ENABLED)) {
82 /* Get the current interrupt block cookie */
83 (void) ddi_get_iblock_cookie(hba->dip, (uint_t)EMLXS_INUMBER,
84 &iblock);
85
86 /* Create the mutex lock */
74 if (!(hba->intr_flags & EMLXS_MSI_ENABLED)) {
75 /* Get the current interrupt block cookie */
76 (void) ddi_get_iblock_cookie(hba->dip, (uint_t)EMLXS_INUMBER,
77 &iblock);
78
79 /* Create the mutex lock */
87 mutex_init(&eventq->lock, buf, MUTEX_DRIVER, (void *)iblock);
80 mutex_init(&eventq->lock, NULL, MUTEX_DRIVER, (void *)iblock);
88 }
89#ifdef MSI_SUPPORT
90 else {
91 /* Create event mutex lock */
81 }
82#ifdef MSI_SUPPORT
83 else {
84 /* Create event mutex lock */
92 mutex_init(&eventq->lock, buf, MUTEX_DRIVER,
85 mutex_init(&eventq->lock, NULL, MUTEX_DRIVER,
93 DDI_INTR_PRI(hba->intr_arg));
94 }
95#endif
96
97 return (1);
98
99} /* emlxs_event_queue_create() */
100

--- 24 unchanged lines hidden (view full) ---

125 wakeup = 1;
126 }
127 }
128
129 if (wakeup) {
130 cv_broadcast(&eventq->lock_cv);
131
132 mutex_exit(&eventq->lock);
86 DDI_INTR_PRI(hba->intr_arg));
87 }
88#endif
89
90 return (1);
91
92} /* emlxs_event_queue_create() */
93

--- 24 unchanged lines hidden (view full) ---

118 wakeup = 1;
119 }
120 }
121
122 if (wakeup) {
123 cv_broadcast(&eventq->lock_cv);
124
125 mutex_exit(&eventq->lock);
133 DELAYMS(10);
126 BUSYWAIT_MS(10);
134 mutex_enter(&eventq->lock);
135 }
136
137 /* Destroy the remaining events */
138 while (eventq->first) {
139 emlxs_event_destroy(hba, eventq->first);
140 }
141

--- 51 unchanged lines hidden (view full) ---

193 }
194 }
195
196 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_dequeued_msg,
197 "%s[%d]: flag=%x missed=%d cnt=%d",
198 entry->evt->label, entry->id, entry->flag, missed, eventq->count);
199
200 /* Call notification handler */
127 mutex_enter(&eventq->lock);
128 }
129
130 /* Destroy the remaining events */
131 while (eventq->first) {
132 emlxs_event_destroy(hba, eventq->first);
133 }
134

--- 51 unchanged lines hidden (view full) ---

186 }
187 }
188
189 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_dequeued_msg,
190 "%s[%d]: flag=%x missed=%d cnt=%d",
191 entry->evt->label, entry->id, entry->flag, missed, eventq->count);
192
193 /* Call notification handler */
201 entry->evt->destroy(entry);
194 if (entry->evt->destroy != emlxs_null_func) {
195 entry->evt->destroy(entry);
196 }
202
203 /* Free context buffer */
204 if (entry->bp && entry->size) {
205 kmem_free(entry->bp, entry->size);
206 }
207
208 /* Free entry buffer */
209 kmem_free(entry, sizeof (emlxs_event_entry_t));

--- 36 unchanged lines hidden (view full) ---

246 mutex_enter(&eventq->lock);
247
248 /* Set the event timer */
249 entry->timestamp = hba->timer_tics;
250 if (evt->timeout) {
251 entry->timer = entry->timestamp + evt->timeout;
252 }
253
197
198 /* Free context buffer */
199 if (entry->bp && entry->size) {
200 kmem_free(entry->bp, entry->size);
201 }
202
203 /* Free entry buffer */
204 kmem_free(entry, sizeof (emlxs_event_entry_t));

--- 36 unchanged lines hidden (view full) ---

241 mutex_enter(&eventq->lock);
242
243 /* Set the event timer */
244 entry->timestamp = hba->timer_tics;
245 if (evt->timeout) {
246 entry->timer = entry->timestamp + evt->timeout;
247 }
248
249 /* Eventq id starts with 1 */
250 if (eventq->next_id == 0) {
251 eventq->next_id = 1;
252 }
253
254 /* Set the event id */
255 entry->id = eventq->next_id++;
256
257 /* Set last event table */
258 mask = evt->mask;
259 for (i = 0; i < 32; i++) {
260 if (mask & 0x01) {
261 eventq->last_id[i] = entry->id;

--- 27 unchanged lines hidden (view full) ---

289 cv_broadcast(&eventq->lock_cv);
290
291 mutex_exit(&eventq->lock);
292
293 return;
294
295failed:
296
254 /* Set the event id */
255 entry->id = eventq->next_id++;
256
257 /* Set last event table */
258 mask = evt->mask;
259 for (i = 0; i < 32; i++) {
260 if (mask & 0x01) {
261 eventq->last_id[i] = entry->id;

--- 27 unchanged lines hidden (view full) ---

289 cv_broadcast(&eventq->lock_cv);
290
291 mutex_exit(&eventq->lock);
292
293 return;
294
295failed:
296
297 /* Call notification handler */
298 entry->evt->destroy(entry);
299
300 if (entry->bp && entry->size) {
301 kmem_free(entry->bp, entry->size);
297 if (bp && size) {
298 kmem_free(bp, size);
302 }
303
304 return;
305
306} /* emlxs_event() */
307
308
309extern void

--- 120 unchanged lines hidden (view full) ---

430 emlxs_event(port, &emlxs_vportrscn_event, bp, size);
431
432 return;
433
434} /* emlxs_log_vportrscn_event() */
435
436
437extern uint32_t
299 }
300
301 return;
302
303} /* emlxs_event() */
304
305
306extern void

--- 120 unchanged lines hidden (view full) ---

427 emlxs_event(port, &emlxs_vportrscn_event, bp, size);
428
429 return;
430
431} /* emlxs_log_vportrscn_event() */
432
433
434extern uint32_t
435emlxs_flush_ct_event(emlxs_port_t *port, uint32_t rxid)
436{
437 emlxs_hba_t *hba = HBA;
438 emlxs_event_queue_t *eventq = &EVENTQ;
439 emlxs_event_entry_t *entry;
440 uint32_t *ptr;
441 uint32_t found = 0;
442
443 mutex_enter(&eventq->lock);
444
445 for (entry = eventq->first; entry != NULL; entry = entry->next) {
446 if ((entry->port != port) ||
447 (entry->evt != &emlxs_ct_event)) {
448 continue;
449 }
450
451 ptr = (uint32_t *)entry->bp;
452 if (rxid == *ptr) {
453 /* This will prevent a CT exchange abort */
454 /* in emlxs_ct_event_destroy() */
455 entry->flag |= EMLXS_DFC_EVENT_DONE;
456
457 emlxs_event_destroy(hba, entry);
458 found = 1;
459 break;
460 }
461 }
462
463 mutex_exit(&eventq->lock);
464
465 return (found);
466
467} /* emlxs_flush_ct_event() */
468
469
470extern uint32_t
438emlxs_log_ct_event(emlxs_port_t *port, uint8_t *payload, uint32_t size,
439 uint32_t rxid)
440{
441 uint8_t *bp;
442 uint32_t *ptr;
443
444 /* Check if the event is being requested */
445 if (emlxs_event_check(port, &emlxs_ct_event) == 0) {

--- 105 unchanged lines hidden (view full) ---

551 if (hba->linkspeed == LA_2GHZ_LINK) {
552 *linkspeed = HBA_PORTSPEED_2GBIT;
553 } else if (hba->linkspeed == LA_4GHZ_LINK) {
554 *linkspeed = HBA_PORTSPEED_4GBIT;
555 } else if (hba->linkspeed == LA_8GHZ_LINK) {
556 *linkspeed = HBA_PORTSPEED_8GBIT;
557 } else if (hba->linkspeed == LA_10GHZ_LINK) {
558 *linkspeed = HBA_PORTSPEED_10GBIT;
471emlxs_log_ct_event(emlxs_port_t *port, uint8_t *payload, uint32_t size,
472 uint32_t rxid)
473{
474 uint8_t *bp;
475 uint32_t *ptr;
476
477 /* Check if the event is being requested */
478 if (emlxs_event_check(port, &emlxs_ct_event) == 0) {

--- 105 unchanged lines hidden (view full) ---

584 if (hba->linkspeed == LA_2GHZ_LINK) {
585 *linkspeed = HBA_PORTSPEED_2GBIT;
586 } else if (hba->linkspeed == LA_4GHZ_LINK) {
587 *linkspeed = HBA_PORTSPEED_4GBIT;
588 } else if (hba->linkspeed == LA_8GHZ_LINK) {
589 *linkspeed = HBA_PORTSPEED_8GBIT;
590 } else if (hba->linkspeed == LA_10GHZ_LINK) {
591 *linkspeed = HBA_PORTSPEED_10GBIT;
592 } else if (hba->linkspeed == LA_16GHZ_LINK) {
593 *linkspeed = HBA_PORTSPEED_16GBIT;
559 } else {
560 *linkspeed = HBA_PORTSPEED_1GBIT;
561 }
562
563 /* Set LIP type */
564 *liptype = port->lip_type;
565 }
566

--- 134 unchanged lines hidden (view full) ---

701 uint32_t size;
702
703 /* Check if the event is being requested */
704 if (emlxs_event_check(port, &emlxs_fcoe_event) == 0) {
705 return;
706 }
707
708 /* Check if this is a FCOE adapter */
594 } else {
595 *linkspeed = HBA_PORTSPEED_1GBIT;
596 }
597
598 /* Set LIP type */
599 *liptype = port->lip_type;
600 }
601

--- 134 unchanged lines hidden (view full) ---

736 uint32_t size;
737
738 /* Check if the event is being requested */
739 if (emlxs_event_check(port, &emlxs_fcoe_event) == 0) {
740 return;
741 }
742
743 /* Check if this is a FCOE adapter */
709 if (hba->model_info.device_id != PCI_DEVICE_ID_LP21000_M) {
744 if (hba->model_info.device_id != PCI_DEVICE_ID_HORNET) {
710 return;
711 }
712
713 size = sizeof (menlo_init_rsp_t);
714
715 if (!(bp = (uint8_t *)kmem_alloc(size, KM_NOSLEEP))) {
716 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
717 "%s: Unable to allocate buffer.", emlxs_fcoe_event.label);

--- 198 unchanged lines hidden (view full) ---

916
917 mutex_exit(&eventq->lock);
918
919 return (0);
920
921} /* emlxs_get_dfc_eventinfo() */
922
923
745 return;
746 }
747
748 size = sizeof (menlo_init_rsp_t);
749
750 if (!(bp = (uint8_t *)kmem_alloc(size, KM_NOSLEEP))) {
751 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
752 "%s: Unable to allocate buffer.", emlxs_fcoe_event.label);

--- 198 unchanged lines hidden (view full) ---

951
952 mutex_exit(&eventq->lock);
953
954 return (0);
955
956} /* emlxs_get_dfc_eventinfo() */
957
958
924uint32_t
959void
925emlxs_get_dfc_event(emlxs_port_t *port, emlxs_dfc_event_t *dfc_event,
926 uint32_t sleep)
927{
928 emlxs_hba_t *hba = HBA;
929 emlxs_event_queue_t *eventq = &EVENTQ;
930 emlxs_event_entry_t *entry;
931 uint32_t found;
932 uint32_t mask;
933 uint32_t i;
934 uint32_t size = 0;
935 uint32_t rc;
936
937 if (dfc_event->dataout && dfc_event->size) {
938 size = dfc_event->size;
939 }
940 dfc_event->size = 0;
941
960emlxs_get_dfc_event(emlxs_port_t *port, emlxs_dfc_event_t *dfc_event,
961 uint32_t sleep)
962{
963 emlxs_hba_t *hba = HBA;
964 emlxs_event_queue_t *eventq = &EVENTQ;
965 emlxs_event_entry_t *entry;
966 uint32_t found;
967 uint32_t mask;
968 uint32_t i;
969 uint32_t size = 0;
970 uint32_t rc;
971
972 if (dfc_event->dataout && dfc_event->size) {
973 size = dfc_event->size;
974 }
975 dfc_event->size = 0;
976
942 if (!dfc_event->event) {
943 return (DFC_ARG_INVALID);
944 }
945
946 /* Calculate the event index */
947 mask = dfc_event->event;
948 for (i = 0; i < 32; i++) {
949 if (mask & 0x01) {
950 break;
951 }
952
953 mask >>= 1;
954 }
955
977 /* Calculate the event index */
978 mask = dfc_event->event;
979 for (i = 0; i < 32; i++) {
980 if (mask & 0x01) {
981 break;
982 }
983
984 mask >>= 1;
985 }
986
987 if (i == 32) {
988 return;
989 }
990
956 mutex_enter(&eventq->lock);
957
958wait_for_event:
959
960 /* Check if no new event has occurred */
961 if (dfc_event->last_id == eventq->last_id[i]) {
962 if (!sleep) {
963 mutex_exit(&eventq->lock);
991 mutex_enter(&eventq->lock);
992
993wait_for_event:
994
995 /* Check if no new event has occurred */
996 if (dfc_event->last_id == eventq->last_id[i]) {
997 if (!sleep) {
998 mutex_exit(&eventq->lock);
964 return (0);
999 return;
965 }
966
967 /* While event is still active and */
968 /* no new event has been logged */
969 while ((dfc_event->event & hba->event_mask) &&
970 (dfc_event->last_id == eventq->last_id[i])) {
971
972 rc = cv_wait_sig(&eventq->lock_cv, &eventq->lock);
973
974 /* Check if thread was killed by kernel */
975 if (rc == 0) {
976 dfc_event->pid = 0;
977 dfc_event->event = 0;
978 mutex_exit(&eventq->lock);
1000 }
1001
1002 /* While event is still active and */
1003 /* no new event has been logged */
1004 while ((dfc_event->event & hba->event_mask) &&
1005 (dfc_event->last_id == eventq->last_id[i])) {
1006
1007 rc = cv_wait_sig(&eventq->lock_cv, &eventq->lock);
1008
1009 /* Check if thread was killed by kernel */
1010 if (rc == 0) {
1011 dfc_event->pid = 0;
1012 dfc_event->event = 0;
1013 mutex_exit(&eventq->lock);
979 return (0);
1014 return;
980 }
981 }
982
983 /* If the event is no longer registered then */
984 /* return immediately */
985 if (!(dfc_event->event & hba->event_mask)) {
986 mutex_exit(&eventq->lock);
1015 }
1016 }
1017
1018 /* If the event is no longer registered then */
1019 /* return immediately */
1020 if (!(dfc_event->event & hba->event_mask)) {
1021 mutex_exit(&eventq->lock);
987 return (0);
1022 return;
988 }
989 }
990
991 /* !!! An event has occurred since last_id !!! */
992
993 /* Check if event data is not being requested */
994 if (!size) {
995 /* If so, then just return the last event id */
996 dfc_event->last_id = eventq->last_id[i];
997
998 mutex_exit(&eventq->lock);
1023 }
1024 }
1025
1026 /* !!! An event has occurred since last_id !!! */
1027
1028 /* Check if event data is not being requested */
1029 if (!size) {
1030 /* If so, then just return the last event id */
1031 dfc_event->last_id = eventq->last_id[i];
1032
1033 mutex_exit(&eventq->lock);
999 return (0);
1034 return;
1000 }
1001
1002 /* !!! The requester wants the next event buffer !!! */
1003
1004 found = 0;
1005 entry = eventq->first;
1006 while (entry) {
1007 if ((entry->id > dfc_event->last_id) &&

--- 16 unchanged lines hidden (view full) ---

1024 /* !!! Next event found !!! */
1025
1026 /* Copy the context buffer to the buffer provided */
1027 if (entry->bp && entry->size) {
1028 if (entry->size < size) {
1029 size = entry->size;
1030 }
1031
1035 }
1036
1037 /* !!! The requester wants the next event buffer !!! */
1038
1039 found = 0;
1040 entry = eventq->first;
1041 while (entry) {
1042 if ((entry->id > dfc_event->last_id) &&

--- 16 unchanged lines hidden (view full) ---

1059 /* !!! Next event found !!! */
1060
1061 /* Copy the context buffer to the buffer provided */
1062 if (entry->bp && entry->size) {
1063 if (entry->size < size) {
1064 size = entry->size;
1065 }
1066
1032 if (ddi_copyout((void *)entry->bp, dfc_event->dataout, size,
1033 dfc_event->mode) != 0) {
1034 mutex_exit(&eventq->lock);
1067 bcopy((void *)entry->bp, dfc_event->dataout, size);
1035
1068
1036 return (DFC_COPYOUT_ERROR);
1037 }
1038
1039 /* Event has been retrieved by DFCLIB */
1040 entry->flag |= EMLXS_DFC_EVENT_DONE;
1041
1042 dfc_event->size = size;
1043 }
1044
1045 dfc_event->last_id = entry->id;
1046
1047 mutex_exit(&eventq->lock);
1048
1069 /* Event has been retrieved by DFCLIB */
1070 entry->flag |= EMLXS_DFC_EVENT_DONE;
1071
1072 dfc_event->size = size;
1073 }
1074
1075 dfc_event->last_id = entry->id;
1076
1077 mutex_exit(&eventq->lock);
1078
1049 return (0);
1079 return;
1050
1051} /* emlxs_get_dfc_event() */
1052
1053
1054uint32_t
1055emlxs_kill_dfc_event(emlxs_port_t *port, emlxs_dfc_event_t *dfc_event)
1056{
1057 emlxs_hba_t *hba = HBA;

--- 288 unchanged lines hidden (view full) ---

1346
1347 emlxs_event(port, &emlxs_sd_scsi_event, bp, size);
1348
1349 return;
1350
1351} /* emlxs_log_sd_scsi_check_event() */
1352
1353
1080
1081} /* emlxs_get_dfc_event() */
1082
1083
1084uint32_t
1085emlxs_kill_dfc_event(emlxs_port_t *port, emlxs_dfc_event_t *dfc_event)
1086{
1087 emlxs_hba_t *hba = HBA;

--- 288 unchanged lines hidden (view full) ---

1376
1377 emlxs_event(port, &emlxs_sd_scsi_event, bp, size);
1378
1379 return;
1380
1381} /* emlxs_log_sd_scsi_check_event() */
1382
1383
1354uint32_t
1384void
1355emlxs_get_sd_event(emlxs_port_t *port, emlxs_dfc_event_t *dfc_event,
1356 uint32_t sleep)
1357{
1358 emlxs_hba_t *hba = HBA;
1359 emlxs_event_queue_t *eventq = &EVENTQ;
1360 emlxs_event_entry_t *entry;
1361 uint32_t found;
1362 uint32_t mask;
1363 uint32_t i;
1364 uint32_t size = 0;
1365 uint32_t rc;
1366
1367 if (dfc_event->dataout && dfc_event->size) {
1368 size = dfc_event->size;
1369 }
1370 dfc_event->size = 0;
1371
1385emlxs_get_sd_event(emlxs_port_t *port, emlxs_dfc_event_t *dfc_event,
1386 uint32_t sleep)
1387{
1388 emlxs_hba_t *hba = HBA;
1389 emlxs_event_queue_t *eventq = &EVENTQ;
1390 emlxs_event_entry_t *entry;
1391 uint32_t found;
1392 uint32_t mask;
1393 uint32_t i;
1394 uint32_t size = 0;
1395 uint32_t rc;
1396
1397 if (dfc_event->dataout && dfc_event->size) {
1398 size = dfc_event->size;
1399 }
1400 dfc_event->size = 0;
1401
1372 if (!dfc_event->event) {
1373 return (DFC_ARG_INVALID);
1374 }
1375
1376 /* Calculate the event index */
1377 mask = dfc_event->event;
1378 for (i = 0; i < 32; i++) {
1379 if (mask & 0x01) {
1380 break;
1381 }
1382
1383 mask >>= 1;
1384 }
1385
1402 /* Calculate the event index */
1403 mask = dfc_event->event;
1404 for (i = 0; i < 32; i++) {
1405 if (mask & 0x01) {
1406 break;
1407 }
1408
1409 mask >>= 1;
1410 }
1411
1412 if (i == 32) {
1413 return;
1414 }
1415
1386 mutex_enter(&eventq->lock);
1387
1388wait_for_event:
1389
1390 /* Check if no new event has ocurred */
1391 if (dfc_event->last_id == eventq->last_id[i]) {
1392 if (!sleep) {
1393 mutex_exit(&eventq->lock);
1416 mutex_enter(&eventq->lock);
1417
1418wait_for_event:
1419
1420 /* Check if no new event has ocurred */
1421 if (dfc_event->last_id == eventq->last_id[i]) {
1422 if (!sleep) {
1423 mutex_exit(&eventq->lock);
1394 return (0);
1424 return;
1395 }
1396
1397 /* While event is active and no new event has been logged */
1398 while ((dfc_event->event & port->sd_event_mask) &&
1399 (dfc_event->last_id == eventq->last_id[i])) {
1400 rc = cv_wait_sig(&eventq->lock_cv, &eventq->lock);
1401
1402 /* Check if thread was killed by kernel */
1403 if (rc == 0) {
1404 dfc_event->pid = 0;
1405 dfc_event->event = 0;
1406 mutex_exit(&eventq->lock);
1425 }
1426
1427 /* While event is active and no new event has been logged */
1428 while ((dfc_event->event & port->sd_event_mask) &&
1429 (dfc_event->last_id == eventq->last_id[i])) {
1430 rc = cv_wait_sig(&eventq->lock_cv, &eventq->lock);
1431
1432 /* Check if thread was killed by kernel */
1433 if (rc == 0) {
1434 dfc_event->pid = 0;
1435 dfc_event->event = 0;
1436 mutex_exit(&eventq->lock);
1407 return (0);
1437 return;
1408 }
1409 }
1410
1411 /* If the event is no longer registered then return */
1412 if (!(dfc_event->event & port->sd_event_mask)) {
1413 mutex_exit(&eventq->lock);
1438 }
1439 }
1440
1441 /* If the event is no longer registered then return */
1442 if (!(dfc_event->event & port->sd_event_mask)) {
1443 mutex_exit(&eventq->lock);
1414 return (0);
1444 return;
1415 }
1416 }
1417
1418 /* !!! An event has occurred since last_id !!! */
1419
1420 /* Check if event data is not being requested */
1421 if (!size) {
1422 /* If so, then just return the last event id */
1423 dfc_event->last_id = eventq->last_id[i];
1424
1425 mutex_exit(&eventq->lock);
1445 }
1446 }
1447
1448 /* !!! An event has occurred since last_id !!! */
1449
1450 /* Check if event data is not being requested */
1451 if (!size) {
1452 /* If so, then just return the last event id */
1453 dfc_event->last_id = eventq->last_id[i];
1454
1455 mutex_exit(&eventq->lock);
1426 return (0);
1456 return;
1427 }
1428
1429 /* !!! The requester wants the next event buffer !!! */
1430
1431 found = 0;
1432 entry = eventq->first;
1433 while (entry) {
1434 if ((entry->id > dfc_event->last_id) &&

--- 17 unchanged lines hidden (view full) ---

1452 /* !!! Next event found !!! */
1453
1454 /* Copy the context buffer to the buffer provided */
1455 if (entry->bp && entry->size) {
1456 if (entry->size < size) {
1457 size = entry->size;
1458 }
1459
1457 }
1458
1459 /* !!! The requester wants the next event buffer !!! */
1460
1461 found = 0;
1462 entry = eventq->first;
1463 while (entry) {
1464 if ((entry->id > dfc_event->last_id) &&

--- 17 unchanged lines hidden (view full) ---

1482 /* !!! Next event found !!! */
1483
1484 /* Copy the context buffer to the buffer provided */
1485 if (entry->bp && entry->size) {
1486 if (entry->size < size) {
1487 size = entry->size;
1488 }
1489
1460 if (ddi_copyout((void *) entry->bp, dfc_event->dataout,
1461 size, dfc_event->mode) != 0) {
1462 mutex_exit(&eventq->lock);
1490 bcopy((void *)entry->bp, dfc_event->dataout, size);
1463
1491
1464 return (DFC_COPYOUT_ERROR);
1465 }
1466
1467 /* Event has been retrieved by SANDIAG */
1468 entry->flag |= EMLXS_SD_EVENT_DONE;
1469
1470 dfc_event->size = size;
1471 }
1472
1473 dfc_event->last_id = entry->id;
1474
1475 mutex_exit(&eventq->lock);
1476
1492 /* Event has been retrieved by SANDIAG */
1493 entry->flag |= EMLXS_SD_EVENT_DONE;
1494
1495 dfc_event->size = size;
1496 }
1497
1498 dfc_event->last_id = entry->id;
1499
1500 mutex_exit(&eventq->lock);
1501
1477 return (0);
1502 return;
1478
1479} /* emlxs_get_sd_event */
1480#endif /* SAN_DIAG_SUPPORT */
1503
1504} /* emlxs_get_sd_event */
1505#endif /* SAN_DIAG_SUPPORT */