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 */ |