Lines Matching defs:port
56 * locking to access the port array itself. Access to the individual
57 * ports are synchronized at the port level.
63 /* DS SP port id */
108 typedef void (*ds_msg_handler_t)(ds_port_t *port, caddr_t buf, size_t len);
109 static void ds_handle_init_req(ds_port_t *port, caddr_t buf, size_t len);
110 static void ds_handle_init_ack(ds_port_t *port, caddr_t buf, size_t len);
111 static void ds_handle_init_nack(ds_port_t *port, caddr_t buf, size_t len);
112 static void ds_handle_reg_req(ds_port_t *port, caddr_t buf, size_t len);
113 static void ds_handle_reg_ack(ds_port_t *port, caddr_t buf, size_t len);
114 static void ds_handle_reg_nack(ds_port_t *port, caddr_t buf, size_t len);
115 static void ds_handle_unreg_req(ds_port_t *port, caddr_t buf, size_t len);
116 static void ds_handle_unreg_ack(ds_port_t *port, caddr_t buf, size_t len);
117 static void ds_handle_unreg_nack(ds_port_t *port, caddr_t buf, size_t len);
118 static void ds_handle_data(ds_port_t *port, caddr_t buf, size_t len);
119 static void ds_handle_nack(ds_port_t *port, caddr_t buf, size_t len);
146 static int ds_ldc_init(ds_port_t *port);
150 static int ds_recv_msg(ds_port_t *port, caddr_t msgp, size_t *sizep);
151 static void ds_handle_up_event(ds_port_t *port);
152 static void ds_handle_down_reset_events(ds_port_t *port);
157 static int ds_send_msg(ds_port_t *port, caddr_t msg, size_t msglen);
158 static int ds_send_reg_req(ds_svc_t *svc, ds_port_t *port);
159 static void ds_send_unreg_nack(ds_port_t *port, ds_svc_hdl_t bad_hdl);
160 static void ds_send_data_nack(ds_port_t *port, ds_svc_hdl_t bad_hdl);
168 static void ds_reset_svc(ds_svc_t *svc, ds_port_t *port);
169 static int ds_svc_register_onport(ds_svc_t *svc, ds_port_t *port);
171 static void ds_set_port_ready(ds_port_t *port, uint16_t major, uint16_t minor);
173 /* port utilities */
174 static void ds_port_reset(ds_port_t *port);
175 static ldc_status_t ds_update_ldc_state(ds_port_t *port);
195 ds_port_t *port);
197 ds_port_t *port);
240 ds_update_ldc_state(ds_port_t *port)
246 ASSERT(MUTEX_HELD(&port->lock));
249 * Read status and update ldc state info in port structure.
251 if ((rv = ldc_status(port->ldc.hdl, &ldc_state)) != 0) {
253 PORTID(port), __func__, ds_errno_to_str(rv, ebuf));
254 ldc_state = port->ldc.state;
256 port->ldc.state = ldc_state;
263 ds_handle_down_reset_events(ds_port_t *port)
265 DS_DBG_LDC(CE_NOTE, "ds@%lx: %s: entered" DS_EOL, PORTID(port),
269 mutex_enter(&port->lock);
271 ds_sys_drain_events(port);
273 (void) ds_update_ldc_state(port);
275 /* reset the port state */
276 ds_port_reset(port);
279 (void) ldc_up(port->ldc.hdl);
281 mutex_exit(&port->lock);
284 ds_handle_up_event(port);
286 DS_DBG_LDC(CE_NOTE, "ds@%lx: %s: exit" DS_EOL, PORTID(port), __func__);
290 ds_handle_up_event(ds_port_t *port)
294 DS_DBG_LDC(CE_NOTE, "ds@%lx: %s: entered" DS_EOL, PORTID(port),
297 mutex_enter(&port->lock);
299 ldc_state = ds_update_ldc_state(port);
301 mutex_exit(&port->lock);
303 if ((ldc_state == LDC_UP) && IS_DS_PORT(port)) {
307 ds_send_init_req(port);
310 DS_DBG_LDC(CE_NOTE, "ds@%lx: %s: exit" DS_EOL, PORTID(port), __func__);
316 ds_port_t *port = (ds_port_t *)arg;
320 PORTID(port), __func__, decode_ldc_events(event, evstring),
325 DS_EOL, PORTID(port), __func__);
330 ds_handle_down_reset_events(port);
335 ds_handle_up_event(port);
339 if (port->ldc.state != LDC_UP) {
341 "port not up" DS_EOL, PORTID(port), __func__);
345 if (ds_sys_dispatch_func(ds_handle_recv, port)) {
347 " event", PORTID(port));
353 "not supported" DS_EOL, PORTID(port), __func__);
358 "0x%llx" DS_EOL, PORTID(port), __func__,
362 DS_DBG_LDC(CE_NOTE, "ds@%lx: %s: exit" DS_EOL, PORTID(port), __func__);
368 ds_ldc_init(ds_port_t *port)
372 caddr_t ldc_cb_arg = (caddr_t)port;
375 ASSERT(MUTEX_HELD(&port->lock));
378 PORTID(port), __func__, (u_longlong_t)port->ldc.id);
385 if ((rv = ldc_init(port->ldc.id, &ldc_attr, &port->ldc.hdl)) != 0) {
387 DS_EOL, PORTID(port), __func__, port->ldc.id,
392 rv = ldc_reg_callback(port->ldc.hdl, ds_ldc_cb, ldc_cb_arg);
395 DS_EOL, PORTID(port), __func__, ds_errno_to_str(rv, ebuf));
399 ds_sys_ldc_init(port);
404 ds_ldc_fini(ds_port_t *port)
409 ASSERT(port->state >= DS_PORT_LDC_INIT);
410 ASSERT(MUTEX_HELD(&port->lock));
412 DS_DBG_LDC(CE_NOTE, "ds@%lx: %s: ldc_id=%ld" DS_EOL, PORTID(port),
413 __func__, port->ldc.id);
415 if ((rv = ldc_close(port->ldc.hdl)) != 0) {
417 PORTID(port), __func__, ds_errno_to_str(rv, ebuf));
421 if ((rv = ldc_unreg_callback(port->ldc.hdl)) != 0) {
423 DS_EOL, PORTID(port), __func__, ds_errno_to_str(rv, ebuf));
427 if ((rv = ldc_fini(port->ldc.hdl)) != 0) {
429 PORTID(port), __func__, ds_errno_to_str(rv, ebuf));
433 port->ldc.id = (uint64_t)-1;
434 port->ldc.hdl = NULL;
435 port->ldc.state = 0;
447 ds_recv_msg(ds_port_t *port, caddr_t msgp, size_t *sizep)
456 ASSERT(MUTEX_HELD(&port->rcv_lock));
461 PORTID(port), bytes_req);
467 mutex_enter(&port->lock);
468 if (port->ldc.state == LDC_UP) {
469 rv = ldc_read(port->ldc.hdl, msgp, &nbytes);
472 mutex_exit(&port->lock);
478 PORTID(port), __func__,
486 PORTID(port), nbytes, retry_count);
504 " no data available" DS_EOL, PORTID(port));
516 "message" DS_EOL, PORTID(port));
529 ds_port_t *port = (ds_port_t *)arg;
540 DS_DBG_LDC(CE_NOTE, "ds@%lx: %s..." DS_EOL, PORTID(port), __func__);
549 mutex_enter(&port->rcv_lock);
552 mutex_enter(&port->lock);
553 if (port->ldc.state == LDC_UP) {
554 rv = ldc_chkq(port->ldc.hdl, &hasdata);
557 mutex_exit(&port->lock);
562 PORTID(port), __func__);
573 if ((rv = ds_recv_msg(port, currp, &read_size)) != 0) {
585 DS_EOL, PORTID(port), read_size, DS_HDR_SZ);
601 PORTID(port), __func__, (int)read_size);
608 if ((rv = ds_recv_msg(port, currp, &read_size)) != 0) {
617 PORTID(port), __func__, (DS_HDR_SZ + read_size),
632 devent->port = port;
637 (void) ds_log_add_msg(DS_LOG_IN(port->id), msg, msglen);
641 "event handler", PORTID(port));
646 mutex_exit(&port->rcv_lock);
650 ds_handle_down_reset_events(port);
653 DS_DBG_LDC(CE_NOTE, "ds@%lx: %s done" DS_EOL, PORTID(port), __func__);
661 ds_port_t *port;
663 port = event->port;
669 PORTID(port), hdr->msg_type);
671 (*ds_msg_handlers[hdr->msg_type])(port, event->buf,
675 "type (%d)" DS_EOL, PORTID(port), hdr->msg_type);
683 ds_send_msg(ds_port_t *port, caddr_t msg, size_t msglen)
690 DS_DBG_LDC(CE_NOTE, "ds@%lx: %s msglen: %ld" DS_EOL, PORTID(port),
694 (void) ds_log_add_msg(DS_LOG_OUT(port->id), (uint8_t *)msg, msglen);
697 * Ensure that no other messages can be sent on this port by holding
701 mutex_enter(&port->tx_lock);
704 mutex_enter(&port->lock);
705 if (port->ldc.state == LDC_UP) {
706 rv = ldc_write(port->ldc.hdl, currp, &msglen);
709 mutex_exit(&port->lock);
712 mutex_exit(&port->tx_lock);
714 ds_handle_down_reset_events, port);
722 "remaining" DS_EOL, PORTID(port), rv,
734 mutex_exit(&port->tx_lock);
745 ds_handle_init_req(ds_port_t *port, caddr_t buf, size_t len)
761 "length (%ld), expected %ld" DS_EOL, PORTID(port), len,
769 PORTID(port), req->major_vers, req->minor_vers);
791 PORTID(port), MIN(new_minor, req->minor_vers));
804 PORTID(port), new_major);
810 (void) ds_send_msg(port, msg, msglen);
814 ds_set_port_ready(port, req->major_vers, ack->minor_vers);
819 ds_handle_init_ack(ds_port_t *port, caddr_t buf, size_t len)
830 "length (%ld), expected %ld" DS_EOL, PORTID(port), len,
837 mutex_enter(&port->lock);
839 if (port->state == DS_PORT_READY) {
840 DS_DBG_PRCL(CE_NOTE, "ds@%lx: <init_ack: port ready" DS_EOL,
841 PORTID(port));
842 mutex_exit(&port->lock);
846 if (port->state != DS_PORT_INIT_REQ) {
848 DS_EOL, PORTID(port), port->state);
849 mutex_exit(&port->lock);
853 ver = &(ds_vers[port->ver_idx]);
856 mutex_exit(&port->lock);
858 DS_DBG_PRCL(CE_NOTE, "ds@%lx: <init_ack: port ready v%d.%d" DS_EOL,
859 PORTID(port), major, minor);
861 ds_set_port_ready(port, major, minor);
865 ds_handle_init_nack(ds_port_t *port, caddr_t buf, size_t len)
875 "length (%ld), expected %ld" DS_EOL, PORTID(port), len,
882 mutex_enter(&port->lock);
884 if (port->state != DS_PORT_INIT_REQ) {
886 DS_EOL, PORTID(port), port->state);
887 mutex_exit(&port->lock);
891 ver = &(ds_vers[port->ver_idx]);
894 DS_EOL, PORTID(port), ver->major, ver->minor, nack->major_vers);
899 DS_EOL, PORTID(port));
900 mutex_exit(&port->lock);
909 for (idx = port->ver_idx; idx < DS_NUM_VER; idx++) {
919 "supported" DS_EOL, PORTID(port), nack->major_vers);
921 mutex_exit(&port->lock);
927 port->ver_idx = idx;
928 port->state = DS_PORT_LDC_INIT;
929 mutex_exit(&port->lock);
931 ds_send_init_req(port);
936 ds_find_svc_by_id_port(char *svc_id, int is_client, ds_port_t *port)
953 if (port != NULL && svc->port == port) {
966 ds_handle_reg_req(ds_port_t *port, caddr_t buf, size_t len)
985 PORTID(port), len, explen);
992 DS_EOL, PORTID(port), req->svc_id, req->major_vers, req->minor_vers,
997 DS_HDL_ISCLIENT(req->svc_handle) == 0, port);
1016 PORTID(port), req->svc_id);
1020 (void) ds_send_msg(port, msg, msglen);
1025 PORTID(port), req->svc_id, (u_longlong_t)svc->hdl);
1044 "client, state (%x)" DS_EOL, PORTID(port),
1051 "client" DS_EOL, PORTID(port), req->svc_id);
1057 PORTID(port), req->svc_id, svc->state);
1058 (void) ds_svc_unregister(svc, port);
1061 (void) ds_svc_port_up(svc, port);
1062 (void) ds_svc_register_onport(svc, port);
1082 "svc_portid: %d" DS_EOL, PORTID(port), req->svc_id,
1084 (int)(svc->port == NULL ? -1 : PORTID(svc->port)));
1087 * it's not on this port, clone it.
1090 if (svc->port != NULL && port == svc->port) {
1095 (void) ds_svc_unregister(svc, port);
1108 svc->port = port;
1134 DS_EOL, PORTID(port), svc->cap.svc_id,
1152 DS_EOL, PORTID(port), svc->cap.svc_id, new_major);
1156 (void) ds_send_msg(port, msg, msglen);
1161 ds_handle_reg_ack(ds_port_t *port, caddr_t buf, size_t len)
1172 "length (%ld), expected %ld" DS_EOL, PORTID(port), len,
1188 DS_EOL, PORTID(port), (u_longlong_t)ack->svc_handle);
1195 PORTID(port), svc->state);
1220 svc->port = port;
1223 DS_EOL, PORTID(port), svc->cap.svc_id, svc->ver.major,
1244 ds_port_is_ready(ds_port_t *port)
1248 mutex_enter(&port->lock);
1249 is_ready = (port->ldc.state == LDC_UP) &&
1250 (port->state == DS_PORT_READY);
1251 mutex_exit(&port->lock);
1258 ds_port_t *port;
1282 * If the port is not in the available list,
1289 port = &ds_ports[portid];
1291 if (!ds_port_is_ready(port))
1295 portid, __func__, (uint_t)(port->ldc.id));
1299 if (ds_send_reg_req(svc, port) == 0) {
1308 /* reset the service to try the next port */
1309 ds_reset_svc(svc, port);
1314 ds_handle_reg_nack(ds_port_t *port, caddr_t buf, size_t len)
1324 "length (%ld), expected %ld" DS_EOL, PORTID(port), len,
1338 DS_EOL, PORTID(port), (u_longlong_t)nack->svc_handle);
1348 DS_EOL, PORTID(port), (u_longlong_t)nack->svc_handle);
1355 "invalid state (%d)" DS_EOL, PORTID(port), svc->cap.svc_id,
1362 " for %s" DS_EOL, PORTID(port), svc->cap.svc_id);
1363 ds_reset_svc(svc, port);
1373 DS_EOL, PORTID(port), svc->cap.svc_id);
1374 ds_reset_svc(svc, port);
1376 ds_try_next_port(svc, PORTID(port) + 1);
1381 DS_EOL, PORTID(port), svc->cap.svc_id,
1399 DS_EOL, PORTID(port), svc->cap.svc_id, nack->major_vers);
1400 ds_reset_svc(svc, port);
1402 ds_try_next_port(svc, PORTID(port) + 1);
1417 ds_handle_unreg_req(ds_port_t *port, caddr_t buf, size_t len)
1431 "length (%ld), expected %ld" DS_EOL, PORTID(port), len,
1442 ((svc = ds_find_clnt_svc_by_hdl_port(req->svc_handle, port))
1444 svc->port != port))) {
1446 mutex_enter(&port->lock);
1447 is_up = (port->ldc.state == LDC_UP);
1448 mutex_exit(&port->lock);
1452 DS_EOL, PORTID(port), (u_longlong_t)req->svc_handle);
1453 ds_send_unreg_nack(port, req->svc_handle);
1458 PORTID(port), svc->cap.svc_id, (u_longlong_t)req->svc_handle);
1460 (void) ds_svc_unregister(svc, svc->port);
1463 PORTID(port), svc->cap.svc_id, (u_longlong_t)req->svc_handle);
1480 (void) ds_send_msg(port, msg, msglen);
1486 ds_handle_unreg_ack(ds_port_t *port, caddr_t buf, size_t len)
1494 "length (%ld), expected %ld" DS_EOL, PORTID(port), len,
1502 PORTID(port), (u_longlong_t)ack->svc_handle);
1515 DS_EOL, PORTID(port), (u_longlong_t)ack->svc_handle);
1523 ds_handle_unreg_nack(ds_port_t *port, caddr_t buf, size_t len)
1531 "length (%ld), expected %ld" DS_EOL, PORTID(port), len,
1539 PORTID(port), (u_longlong_t)nack->svc_handle);
1552 DS_EOL, PORTID(port), (u_longlong_t)nack->svc_handle);
1560 ds_handle_data(ds_port_t *port, caddr_t buf, size_t len)
1572 "(%ld), expected at least %ld" DS_EOL, PORTID(port), len,
1587 if ((svc = ds_find_clnt_svc_by_hdl_port(data->svc_handle, port))
1592 DS_EOL, PORTID(port),
1594 ds_send_data_nack(port, data->svc_handle);
1602 PORTID(port), svc->cap.svc_id, (u_longlong_t)svc->hdl);
1610 ds_handle_nack(ds_port_t *port, caddr_t buf, size_t len)
1619 "length (%ld), expected %ld" DS_EOL, PORTID(port), len,
1627 DS_EOL, PORTID(port), (u_longlong_t)nack->svc_handle,
1635 port)) == NULL) {
1643 " as invalid" DS_EOL, PORTID(port),
1646 (void) ds_svc_unregister(svc, svc->port);
1652 /* Initialize the port */
1654 ds_send_init_req(ds_port_t *port)
1659 ds_ver_t *vers = &ds_vers[port->ver_idx];
1661 mutex_enter(&port->lock);
1662 if (port->state != DS_PORT_LDC_INIT) {
1664 DS_EOL, PORTID(port), port->state);
1665 mutex_exit(&port->lock);
1668 mutex_exit(&port->lock);
1671 PORTID(port), vers->major, vers->minor);
1683 if (ds_send_msg(port, (caddr_t)hdr, msglen) == 0) {
1685 * We've left the port state unlocked over the malloc/send,
1689 mutex_enter(&port->lock);
1690 if (port->state == DS_PORT_LDC_INIT)
1691 port->state = DS_PORT_INIT_REQ;
1692 mutex_exit(&port->lock);
1698 ds_send_reg_req(ds_svc_t *svc, ds_port_t *port)
1711 "for svc '%s'" DS_EOL, PORTID(port), svc->state,
1716 mutex_enter(&port->lock);
1719 if (port->ldc.state != LDC_UP) {
1722 DS_EOL, PORTID(port), port->ldc.id);
1723 mutex_exit(&port->lock);
1727 /* make sure port is ready */
1728 if (port->state != DS_PORT_READY) {
1730 DS_DBG_PRCL(CE_NOTE, "ds@%lx: reg_req>: port is not ready"
1731 DS_EOL, PORTID(port));
1732 mutex_exit(&port->lock);
1736 mutex_exit(&port->lock);
1759 DS_EOL, PORTID(port), svc->cap.svc_id, ver->major, ver->minor,
1762 if ((rv = ds_send_msg(port, msg, msglen)) != 0) {
1763 svc->port = port;
1783 ds_port_t *port = svc->port;
1786 if (port == NULL) {
1788 "associated with a port" DS_EOL, svc->cap.svc_id);
1792 mutex_enter(&port->lock);
1795 if (port->ldc.state != LDC_UP) {
1798 DS_EOL, PORTID(port), port->ldc.id);
1799 mutex_exit(&port->lock);
1803 /* make sure port is ready */
1804 if (port->state != DS_PORT_READY) {
1806 cmn_err(CE_WARN, "ds@%lx: unreg_req>: port is not ready" DS_EOL,
1807 PORTID(port));
1808 mutex_exit(&port->lock);
1812 mutex_exit(&port->lock);
1831 PORTID(port), (svc->cap.svc_id) ? svc->cap.svc_id : "NULL",
1834 if ((rv = ds_send_msg(port, msg, msglen)) != 0) {
1843 ds_send_unreg_nack(ds_port_t *port, ds_svc_hdl_t bad_hdl)
1850 mutex_enter(&port->lock);
1853 if (port->ldc.state != LDC_UP) {
1856 DS_EOL, PORTID(port), port->ldc.id);
1857 mutex_exit(&port->lock);
1861 /* make sure port is ready */
1862 if (port->state != DS_PORT_READY) {
1864 cmn_err(CE_WARN, "ds@%lx: unreg_nack>: port is not ready"
1865 DS_EOL, PORTID(port));
1866 mutex_exit(&port->lock);
1870 mutex_exit(&port->lock);
1885 PORTID(port), (u_longlong_t)bad_hdl);
1887 (void) ds_send_msg(port, msg, msglen);
1892 ds_send_data_nack(ds_port_t *port, ds_svc_hdl_t bad_hdl)
1899 mutex_enter(&port->lock);
1902 if (port->ldc.state != LDC_UP) {
1905 DS_EOL, PORTID(port), port->ldc.id);
1906 mutex_exit(&port->lock);
1910 /* make sure port is ready */
1911 if (port->state != DS_PORT_READY) {
1913 cmn_err(CE_WARN, "ds@%lx: data_nack>: port is not ready" DS_EOL,
1914 PORTID(port));
1915 mutex_exit(&port->lock);
1919 mutex_exit(&port->lock);
1935 PORTID(port), (u_longlong_t)bad_hdl);
1937 (void) ds_send_msg(port, msg, msglen);
2007 * function for each service on a port. A non-zero return value from the
2108 ds_set_svc_port_tried(char *svc_id, ds_port_t *port)
2120 DS_PORTSET_ADD(svc->tried, PORTID(port));
2125 ds_svc_register_onport(ds_svc_t *svc, ds_port_t *port)
2132 if (!DS_PORT_IN_SET(svc->avail, PORTID(port)))
2135 if (DS_PORT_IN_SET(svc->tried, PORTID(port)))
2138 if (!ds_port_is_ready(port))
2144 DS_PORTSET_ADD(svc->tried, PORTID(port));
2146 ds_set_svc_port_tried(svc->cap.svc_id, port);
2151 if (PORTID(port) == ds_sp_port_id) {
2156 if (ds_send_reg_req(svc, port) == 0) {
2163 ds_reset_svc(svc, port);
2185 ds_port_t *port;
2207 * numbered port and continue until a registration message
2213 * If the port is not in the available list,
2220 port = &ds_ports[idx];
2221 if (ds_svc_register_onport(svc, port)) {
2233 ds_port_t *port = (ds_port_t *)arg;
2242 /* make sure the service is using this port */
2243 if (svc->port != port) {
2247 if (port) {
2249 " hdl=0x%09lx" DS_EOL, PORTID(port), svc->cap.svc_id,
2252 DS_DBG(CE_NOTE, "port=NULL: svc_unreg: id='%s', ver=%d.%d, "
2258 ds_reset_svc(svc, port);
2283 ds_port_t *port = (ds_port_t *)arg;
2290 DS_PORTSET_ADD(svc->avail, port->id);
2291 DS_PORTSET_DEL(svc->tried, port->id);
2297 ds_set_port_ready(ds_port_t *port, uint16_t major, uint16_t minor)
2301 mutex_enter(&port->lock);
2302 was_ready = (port->state == DS_PORT_READY);
2304 port->state = DS_PORT_READY;
2305 port->ver.major = major;
2306 port->ver.minor = minor;
2308 mutex_exit(&port->lock);
2313 * The port came up, so update all the services
2320 (void) ds_walk_svcs(ds_svc_port_up, port);
2321 (void) ds_walk_svcs(ds_svc_register_onport_walker, port);
2381 ds_reset_svc(ds_svc_t *svc, ds_port_t *port)
2390 svc->port = NULL;
2391 if (port) {
2392 DS_PORTSET_DEL(svc->avail, port->id);
2427 ds_port_reset(ds_port_t *port)
2430 ASSERT(MUTEX_HELD(&port->lock));
2433 (void) ds_walk_svcs(ds_svc_unregister, port);
2435 port->ver_idx = 0;
2436 port->ver.major = 0;
2437 port->ver.minor = 0;
2438 port->state = DS_PORT_LDC_INIT;
2669 if (svc->port) {
2673 (void) ds_svc_unregister(svc, svc->port);
2731 ds_port_t *port;
2763 if ((port = svc->port) == NULL) {
2764 DS_DBG(CE_NOTE, "%s: service '%s' not associated with a port"
2778 if (port->ldc.state != LDC_UP) {
2805 " payload_len=%d" DS_EOL, PORTID(port), (u_longlong_t)svc->hdl,
2809 if ((rv = ds_send_msg(port, msg, msglen)) != 0) {
2818 ds_port_common_init(ds_port_t *port)
2822 if ((port->flags & DS_PORT_MUTEX_INITED) == 0) {
2823 mutex_init(&port->lock, NULL, MUTEX_DRIVER, NULL);
2824 mutex_init(&port->tx_lock, NULL, MUTEX_DRIVER, NULL);
2825 mutex_init(&port->rcv_lock, NULL, MUTEX_DRIVER, NULL);
2826 port->flags |= DS_PORT_MUTEX_INITED;
2829 port->state = DS_PORT_INIT;
2830 DS_PORTSET_ADD(ds_allports, port->id);
2832 ds_sys_port_init(port);
2834 mutex_enter(&port->lock);
2835 rv = ds_ldc_init(port);
2836 mutex_exit(&port->lock);
2839 * If LDC successfully init'ed, try to kick off protocol for this port.
2842 ds_handle_up_event(port);
2847 ds_port_common_fini(ds_port_t *port)
2849 ASSERT(MUTEX_HELD(&port->lock));
2851 port->state = DS_PORT_FREE;
2853 DS_PORTSET_DEL(ds_allports, port->id);
2855 ds_sys_port_fini(port);
3145 svc->port = NULL;
3151 lb_svc->port = NULL;
3162 ds_find_clnt_svc_by_hdl_port(ds_svc_hdl_t hdl, ds_port_t *port)
3168 PORTID(port), __func__, (u_longlong_t)hdl);
3177 svc->svc_hdl == hdl && svc->port == port) {
3179 "0x%llx: svc%d" DS_EOL, PORTID(port), __func__,
3185 PORTID(port), __func__, (u_longlong_t)hdl);
3208 newsvc->port = NULL;