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 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #ifndef _DS_IMPL_H 28 #define _DS_IMPL_H 29 30 #ifdef __cplusplus 31 extern "C" { 32 #endif 33 34 #include <sys/bitmap.h> 35 #include <sys/ldoms.h> 36 37 38 /* 39 * The Domain Services Protocol 40 * 41 * The DS protocol is divided into two parts. The first is fixed and 42 * must remain exactly the same for *all* versions of the DS protocol. 43 * The only messages supported by the fixed portion of the protocol are 44 * to negotiate a version to use for the rest of the protocol. 45 */ 46 47 /* 48 * Domain Services Header 49 */ 50 typedef struct ds_hdr { 51 uint32_t msg_type; /* message type */ 52 uint32_t payload_len; /* payload length */ 53 } ds_hdr_t; 54 55 #define DS_HDR_SZ (sizeof (ds_hdr_t)) 56 57 /* 58 * DS Fixed Message Types 59 */ 60 #define DS_INIT_REQ 0x0 /* initiate DS connection */ 61 #define DS_INIT_ACK 0x1 /* initiation acknowledgement */ 62 #define DS_INIT_NACK 0x2 /* initiation negative acknowledgment */ 63 64 /* 65 * DS Fixed Initialization Messages 66 */ 67 typedef struct ds_init_req { 68 uint16_t major_vers; /* requested major version */ 69 uint16_t minor_vers; /* requested minor version */ 70 } ds_init_req_t; 71 72 typedef struct ds_init_ack { 73 uint16_t minor_vers; /* highest supported minor version */ 74 } ds_init_ack_t; 75 76 typedef struct ds_init_nack { 77 uint16_t major_vers; /* alternate supported major version */ 78 } ds_init_nack_t; 79 80 /* 81 * DS Message Types for Version 1.0 82 */ 83 #define DS_REG_REQ 0x3 /* register a service */ 84 #define DS_REG_ACK 0x4 /* register acknowledgement */ 85 #define DS_REG_NACK 0x5 /* register failed */ 86 #define DS_UNREG 0x6 /* unregister a service */ 87 #define DS_UNREG_ACK 0x7 /* unregister acknowledgement */ 88 #define DS_UNREG_NACK 0x8 /* unregister failed */ 89 #define DS_DATA 0x9 /* data message */ 90 #define DS_NACK 0xa /* data error */ 91 92 /* result codes */ 93 #define DS_OK 0x0 /* success */ 94 #define DS_REG_VER_NACK 0x1 /* unsupported major version */ 95 #define DS_REG_DUP 0x2 /* duplicate registration attempted */ 96 #define DS_INV_HDL 0x3 /* service handle not valid */ 97 #define DS_TYPE_UNKNOWN 0x4 /* unknown message type received */ 98 99 /* 100 * Service Register Messages 101 */ 102 typedef struct ds_reg_req { 103 uint64_t svc_handle; /* service handle to register */ 104 uint16_t major_vers; /* requested major version */ 105 uint16_t minor_vers; /* requested minor version */ 106 char svc_id[1]; /* service identifier string */ 107 } ds_reg_req_t; 108 109 typedef struct ds_reg_ack { 110 uint64_t svc_handle; /* service handle sent in register */ 111 uint16_t minor_vers; /* highest supported minor version */ 112 } ds_reg_ack_t; 113 114 typedef struct ds_reg_nack { 115 uint64_t svc_handle; /* service handle sent in register */ 116 uint64_t result; /* reason for the failure */ 117 uint16_t major_vers; /* alternate supported major version */ 118 } ds_reg_nack_t; 119 120 /* 121 * Service Unregister Messages 122 */ 123 typedef struct ds_unreg_req { 124 uint64_t svc_handle; /* service handle to unregister */ 125 } ds_unreg_req_t; 126 127 typedef struct ds_unreg_ack { 128 uint64_t svc_handle; /* service handle sent in unregister */ 129 } ds_unreg_ack_t; 130 131 typedef struct ds_unreg_nack { 132 uint64_t svc_handle; /* service handle sent in unregister */ 133 } ds_unreg_nack_t; 134 135 /* 136 * Data Transfer Messages 137 */ 138 typedef struct ds_data_handle { 139 uint64_t svc_handle; /* service handle for data */ 140 } ds_data_handle_t; 141 142 typedef struct ds_data_nack { 143 uint64_t svc_handle; /* service handle sent in data msg */ 144 uint64_t result; /* reason for failure */ 145 } ds_data_nack_t; 146 147 /* 148 * Message Processing Utilities 149 */ 150 #define DS_MSG_TYPE_VALID(type) ((type) <= DS_NACK) 151 #define DS_MSG_LEN(ds_type) (sizeof (ds_hdr_t) + sizeof (ds_type)) 152 153 154 /* 155 * Domain Service Port 156 * 157 * A DS port is a logical representation of an LDC dedicated to 158 * communication between DS endpoints. The ds_port_t maintains state 159 * associated with a connection to a remote endpoint. This includes 160 * the state of the port, the LDC state, the current version of the 161 * DS protocol in use on the port, and other port properties. 162 * 163 * Locking: The port is protected by a single mutex. It must be held 164 * while the port structure is being accessed and also when data is 165 * being read or written using the port 166 */ 167 typedef enum { 168 DS_PORT_FREE, /* port structure not in use */ 169 DS_PORT_INIT, /* port structure created */ 170 DS_PORT_LDC_INIT, /* ldc successfully initialized */ 171 DS_PORT_INIT_REQ, /* initialization handshake sent */ 172 DS_PORT_READY /* init handshake completed */ 173 } ds_port_state_t; 174 175 typedef struct ds_ldc { 176 uint64_t id; /* LDC id */ 177 ldc_handle_t hdl; /* LDC handle */ 178 ldc_status_t state; /* current LDC state */ 179 } ds_ldc_t; 180 181 typedef uint64_t ds_domain_hdl_t; 182 183 #define DS_DHDL_INVALID ((ds_domain_hdl_t)0xffffffff) 184 185 /* port flags */ 186 #define DS_PORT_MUTEX_INITED 0x1 /* mutexes inited? */ 187 188 typedef struct ds_port { 189 uint32_t flags; /* port flags */ 190 kmutex_t lock; /* port and service state lock */ 191 kmutex_t tx_lock; /* tx port lock */ 192 kmutex_t rcv_lock; /* rcv port lock */ 193 uint64_t id; /* port id from MD */ 194 ds_port_state_t state; /* state of the port */ 195 ds_ver_t ver; /* DS protocol version in use */ 196 uint32_t ver_idx; /* index of version during handshake */ 197 ds_ldc_t ldc; /* LDC for this port */ 198 ds_domain_hdl_t domain_hdl; /* LDOMs domain hdl assoc. with port */ 199 char *domain_name; /* LDOMs domain name assoc. with port */ 200 } ds_port_t; 201 202 #define IS_DS_PORT(port) 1 /* VBSC code compatability */ 203 #define PORTID(port) ((ulong_t)((port)->id)) 204 #define PTR_TO_LONG(ptr) ((uint64_t)(ptr)) 205 206 /* 207 * A DS portset is a bitmap that represents a collection of DS 208 * ports. Each bit represent a particular port id. We need 209 * to allocate for the max. number of domains supported, 210 * plus a small number (e.g. for the SP connection). 211 */ 212 #define DS_EXTRA_PORTS 16 213 #define DS_MAX_PORTS (LDOMS_MAX_DOMAINS + DS_EXTRA_PORTS) 214 #define DS_PORTSET_SIZE BT_BITOUL(DS_MAX_PORTS) 215 216 typedef ulong_t ds_portset_t[DS_PORTSET_SIZE]; 217 218 extern ds_port_t ds_ports[DS_MAX_PORTS]; 219 extern ds_portset_t ds_allports; 220 extern ds_portset_t ds_nullport; 221 222 #define DS_PORTID_INVALID ((uint64_t)-1) 223 224 /* DS SP Port ID */ 225 extern uint64_t ds_sp_port_id; 226 227 #define DS_MAX_PORT_ID (DS_MAX_PORTS - 1) 228 229 #define DS_PORT_IN_SET(set, port) BT_TEST((set), (port)) 230 #define DS_PORTSET_ADD(set, port) BT_SET((set), (port)) 231 #define DS_PORTSET_DEL(set, port) BT_CLEAR((set), (port)) 232 #define DS_PORTSET_ISNULL(set) (memcmp((set), ds_nullport, \ 233 sizeof (set)) == 0) 234 #define DS_PORTSET_SETNULL(set) ((void)memset((set), 0, sizeof (set))) 235 #define DS_PORTSET_DUP(set1, set2) ((void)memcpy((set1), (set2), \ 236 sizeof (set1))) 237 238 /* 239 * A DS event consists of a buffer on a port. We explictly use a link to 240 * enequeue/dequeue on non-Solaris environments. On Solaris we use taskq. 241 */ 242 typedef struct ds_event { 243 ds_port_t *port; 244 char *buf; 245 size_t buflen; 246 } ds_event_t; 247 248 /* 249 * LDC Information 250 */ 251 #define DS_STREAM_MTU 4096 252 253 /* 254 * Machine Description Constants 255 */ 256 #define DS_MD_ROOT_NAME "domain-services" 257 #define DS_MD_PORT_NAME "domain-services-port" 258 #define DS_MD_CHAN_NAME "channel-endpoint" 259 260 /* 261 * DS Services 262 * 263 * A DS Service is a mapping between a DS capability and a client 264 * of the DS framework that provides that capability. It includes 265 * information on the state of the service, the currently negotiated 266 * version of the capability specific protocol, the port that is 267 * currently in use by the capability, etc. 268 */ 269 270 typedef enum { 271 DS_SVC_INVAL, /* svc structure uninitialized */ 272 DS_SVC_FREE, /* svc structure not in use */ 273 DS_SVC_INACTIVE, /* svc not registered */ 274 DS_SVC_REG_PENDING, /* register message sent */ 275 DS_SVC_ACTIVE, /* register message acknowledged */ 276 DS_SVC_UNREG_PENDING /* unregister is pending */ 277 } ds_svc_state_t; 278 279 /* ds_svc flags bits */ 280 #define DSSF_ISCLIENT 0x0001 /* client service */ 281 #define DSSF_ISUSER 0x0002 /* user land service */ 282 #define DSSF_REGCB_VALID 0x0004 /* ops register callback is valid */ 283 #define DSSF_UNREGCB_VALID 0x0008 /* ops unregister callback is valid */ 284 #define DSSF_DATACB_VALID 0x0010 /* ops data callback is valid */ 285 #define DSSF_LOOPBACK 0x0020 /* loopback */ 286 #define DSSF_PEND_UNREG 0x0040 /* pending unregister */ 287 #define DSSF_ANYCB_VALID (DSSF_REGCB_VALID | DSSF_UNREGCB_VALID | \ 288 DSSF_DATACB_VALID) 289 #define DSSF_USERFLAGS (DSSF_ISCLIENT | DSSF_ISUSER | DSSF_ANYCB_VALID) 290 291 typedef struct ds_svc { 292 ds_capability_t cap; /* capability information */ 293 ds_clnt_ops_t ops; /* client ops vector */ 294 ds_svc_hdl_t hdl; /* handle assigned by DS */ 295 ds_svc_hdl_t svc_hdl; /* remote svc hdl if client svc */ 296 ds_svc_state_t state; /* current service state */ 297 ds_ver_t ver; /* svc protocol version in use */ 298 uint_t ver_idx; /* index into client version array */ 299 ds_port_t *port; /* port for this service */ 300 ds_portset_t avail; /* ports available to this service */ 301 ds_portset_t tried; /* ports tried by this service */ 302 int fixed; /* is svc fixed to port */ 303 uint_t flags; /* service flags */ 304 ds_cb_arg_t uarg; /* user arg for user callbacks */ 305 uint_t drvi; /* driver instance */ 306 void *drv_psp; /* driver per svc ptr */ 307 } ds_svc_t; 308 309 typedef struct ds_svcs { 310 ds_svc_t **tbl; /* ptr to table */ 311 kmutex_t lock; 312 uint_t maxsvcs; /* size of the table */ 313 uint_t nsvcs; /* current number of items */ 314 } ds_svcs_t; 315 316 #define DS_SVC_ISFREE(svc) ((svc == NULL) || (svc->state == DS_SVC_FREE)) 317 #ifndef DS_MAXSVCS_INIT 318 #define DS_MAXSVCS_INIT 32 319 #endif 320 321 /* 322 * A service handle is a 64 bit value with three pieces of information 323 * encoded in it. The upper 32 bits is the index into the table of 324 * a particular service structure. Bit 31 indicates whether the handle 325 * represents a service privider or service client. The lower 31 bits is 326 * a counter that is incremented each time a service structure is reused. 327 */ 328 #define DS_IDX_SHIFT 32 329 #define DS_COUNT_MASK 0x7fffffffull 330 #define DS_HDL_ISCLIENT_BIT 0x80000000ull 331 332 #define DS_ALLOC_HDL(_idx, _count) (((uint64_t)_idx << DS_IDX_SHIFT) | \ 333 ((uint64_t)(_count + 1) & \ 334 DS_COUNT_MASK)) 335 #define DS_HDL2IDX(hdl) (hdl >> DS_IDX_SHIFT) 336 #define DS_HDL2COUNT(hdl) (hdl & DS_COUNT_MASK) 337 #define DS_HDL_ISCLIENT(hdl) ((hdl) & DS_HDL_ISCLIENT_BIT) 338 #define DS_HDL_SET_ISCLIENT(hdl) ((hdl) |= DS_HDL_ISCLIENT_BIT) 339 340 #define DS_INVALID_INSTANCE (-1) 341 342 /* enable/disable taskq processing */ 343 extern boolean_t ds_enabled; 344 345 extern ds_svcs_t ds_svcs; 346 347 /* 348 * DS Message Logging 349 * 350 * The DS framework logs all incoming and outgoing messages to a 351 * ring buffer. This provides the ability to reconstruct a trace 352 * of DS activity for use in debugging. In addition to the message 353 * data, each log entry contains a timestamp and the destination 354 * of the message. The destination is based on the port number the 355 * message passed through (port number + 1). The sign of the dest 356 * field distinguishes incoming messages from outgoing messages. 357 * Incoming messages have a negative destination field. 358 */ 359 360 typedef struct ds_log_entry { 361 struct ds_log_entry *next; /* next in log or free list */ 362 struct ds_log_entry *prev; /* previous in log */ 363 time_t timestamp; /* time message added to log */ 364 size_t datasz; /* size of the data */ 365 void *data; /* the data itself */ 366 int32_t dest; /* message destination */ 367 } ds_log_entry_t; 368 369 #define DS_LOG_IN(pid) (-(pid + 1)) 370 #define DS_LOG_OUT(pid) (pid + 1) 371 372 /* 373 * DS Log Limits: 374 * 375 * The size of the log is controlled by two limits. The first is 376 * a soft limit that is configurable by the user (via the global 377 * variable ds_log_sz). When this limit is exceeded, each new 378 * message that is added to the log replaces the oldest message. 379 * 380 * The second is a hard limit that is calculated based on the soft 381 * limit (DS_LOG_LIMIT). It is defined to be ~3% above the soft limit. 382 * Once this limit is exceeded, a thread is scheduled to delete old 383 * messages until the size of the log is below the soft limit. 384 */ 385 #define DS_LOG_DEFAULT_SZ (4 * 1024 * 1024) /* 4 MB */ 386 387 #define DS_LOG_LIMIT (ds_log_sz + (ds_log_sz >> 5)) 388 389 #define DS_LOG_ENTRY_SZ(ep) (sizeof (ds_log_entry_t) + (ep)->datasz) 390 391 /* 392 * DS Log Memory Usage: 393 * 394 * The log free list is initialized from a pre-allocated pool of entry 395 * structures (the global ds_log_entry_pool). The number of entries 396 * in the pool (DS_LOG_NPOOL) is the number of entries that would 397 * take up half the default size of the log. 398 * 399 * As messages are added to the log, entry structures are pulled from 400 * the free list. If the free list is empty, memory is allocated for 401 * the entry. When entries are removed from the log, they are placed 402 * on the free list. Allocated memory is only deallocated when the 403 * entire log is destroyed. 404 */ 405 #define DS_LOG_NPOOL ((DS_LOG_DEFAULT_SZ >> 1) / \ 406 sizeof (ds_log_entry_t)) 407 408 #define DS_LOG_POOL_END (ds_log_entry_pool + DS_LOG_NPOOL) 409 410 #define DS_IS_POOL_ENTRY(ep) (((ep) >= ds_log_entry_pool) && \ 411 ((ep) < &(ds_log_entry_pool[DS_LOG_NPOOL]))) 412 413 /* VBSC code compatability related defines */ 414 415 /* VBSC malloc/free are similar to user malloc/free */ 416 #define DS_MALLOC(size) kmem_zalloc(size, KM_SLEEP) 417 #define DS_FREE(ptr, size) kmem_free(ptr, size) 418 419 /* VBSC debug print needs newline, Solaris cmn_err doesn't */ 420 #define DS_EOL 421 422 /* 423 * Results of checking version array with ds_vers_isvalid() 424 */ 425 typedef enum { 426 DS_VERS_OK, 427 DS_VERS_INCREASING_MAJOR_ERR, 428 DS_VERS_INCREASING_MINOR_ERR 429 } ds_vers_check_t; 430 431 /* System specific interfaces */ 432 extern void ds_sys_port_init(ds_port_t *port); 433 extern void ds_sys_port_fini(ds_port_t *port); 434 extern void ds_sys_drain_events(ds_port_t *port); 435 extern int ds_sys_dispatch_func(void (func)(void *), void *arg); 436 extern void ds_sys_ldc_init(ds_port_t *port); 437 438 /* vlds cb access to svc structure */ 439 void ds_cbarg_get_hdl(ds_cb_arg_t arg, ds_svc_hdl_t *hdlp); 440 void ds_cbarg_get_flags(ds_cb_arg_t arg, uint32_t *flagsp); 441 void ds_cbarg_get_drv_info(ds_cb_arg_t arg, int *drvip); 442 void ds_cbarg_get_drv_per_svc_ptr(ds_cb_arg_t arg, void **dpspp); 443 void ds_cbarg_get_domain(ds_cb_arg_t arg, ds_domain_hdl_t *dhdlp); 444 void ds_cbarg_get_service_id(ds_cb_arg_t arg, char **servicep); 445 void ds_cbarg_set_drv_per_svc_ptr(ds_cb_arg_t arg, void *dpsp); 446 int ds_hdl_get_cbarg(ds_svc_hdl_t hdl, ds_cb_arg_t *cbargp); 447 void ds_cbarg_set_cookie(ds_svc_t *svc); 448 int ds_is_my_hdl(ds_svc_hdl_t hdl, int instance); 449 void ds_set_my_dom_hdl_name(ds_domain_hdl_t dhdl, char *name); 450 451 /* initialization functions */ 452 void ds_common_init(void); 453 int ds_ldc_fini(ds_port_t *port); 454 void ds_init_svcs_tbl(uint_t nentries); 455 456 /* message sending functions */ 457 void ds_send_init_req(ds_port_t *port); 458 int ds_send_unreg_req(ds_svc_t *svc); 459 460 /* walker functions */ 461 typedef int (*svc_cb_t)(ds_svc_t *svc, void *arg); 462 int ds_walk_svcs(svc_cb_t svc_cb, void *arg); 463 int ds_svc_ismatch(ds_svc_t *svc, void *arg); 464 int ds_svc_free(ds_svc_t *svc, void *arg); 465 int ds_svc_register(ds_svc_t *svc, void *arg); 466 467 /* service utilities */ 468 ds_svc_t *ds_alloc_svc(void); 469 ds_svc_t *ds_sys_find_svc_by_id_port(char *svc_id, ds_port_t *port, 470 int is_client); 471 ds_svc_t *ds_get_svc(ds_svc_hdl_t hdl); 472 473 /* port utilities */ 474 void ds_port_common_init(ds_port_t *port); 475 void ds_port_common_fini(ds_port_t *port); 476 477 /* misc utilities */ 478 ds_vers_check_t ds_vers_isvalid(ds_ver_t *vers, int nvers); 479 char *ds_errno_to_str(int ds_errno, char *ebuf); 480 char *ds_strdup(char *str); 481 boolean_t negotiate_version(int num_versions, ds_ver_t *sup_versionsp, 482 uint16_t req_major, uint16_t *new_majorp, uint16_t *new_minorp); 483 484 /* log functions */ 485 int ds_log_add_msg(int32_t dest, uint8_t *msg, size_t sz); 486 487 /* vlds driver interfaces to ds module */ 488 int ds_ucap_init(ds_capability_t *cap, ds_clnt_ops_t *ops, uint_t flags, 489 int instance, ds_svc_hdl_t *hdlp); 490 int ds_unreg_hdl(ds_svc_hdl_t hdl); 491 int ds_hdl_lookup(char *service, uint_t is_client, ds_svc_hdl_t *hdlp, 492 uint_t maxhdls, uint_t *nhdlsp); 493 int ds_service_lookup(ds_svc_hdl_t hdl, char **servicep, uint_t *is_client); 494 int ds_domain_lookup(ds_svc_hdl_t hdl, ds_domain_hdl_t *dhdlp); 495 int ds_hdl_isready(ds_svc_hdl_t hdl, uint_t *is_ready); 496 void ds_unreg_all(int instance); 497 int ds_dom_name_to_hdl(char *domain_name, ds_domain_hdl_t *dhdlp); 498 int ds_dom_hdl_to_name(ds_domain_hdl_t dhdl, char **domain_namep); 499 int ds_add_port(uint64_t port_id, uint64_t ldc_id, ds_domain_hdl_t dhdl, 500 char *dom_name, int verbose); 501 int ds_remove_port(uint64_t portid, int is_fini); 502 503 /* ds_ucap_init flags */ 504 #define DS_UCAP_CLNT 0x0 /* Service is Client */ 505 #define DS_UCAP_SVC 0x1 /* Service is Server */ 506 507 /* 508 * Error buffer size for ds_errno_to_str 509 */ 510 #define DS_EBUFSIZE 80 511 512 /* 513 * Debugging Features 514 */ 515 #ifdef DEBUG 516 517 #define DS_DBG_BASIC 0x001 518 #define DS_DBG_FLAG_LDC 0x002 519 #define DS_DBG_FLAG_LOG 0x004 520 #define DS_DBG_DUMP_LDC_MSG 0x008 521 #define DS_DBG_FLAG_MD 0x010 522 #define DS_DBG_FLAG_USR 0x020 523 #define DS_DBG_FLAG_VLDS 0x040 524 #define DS_DBG_FLAG_PRCL 0x080 525 #define DS_DBG_FLAG_RCVQ 0x100 526 #define DS_DBG_FLAG_LOOP 0x200 527 528 #define DS_DBG if (ds_debug & DS_DBG_BASIC) cmn_err 529 #define DS_DBG_LDC if (ds_debug & DS_DBG_FLAG_LDC) cmn_err 530 #define DS_DBG_LOG if (ds_debug & DS_DBG_FLAG_LOG) cmn_err 531 #define DS_DBG_MD if (ds_debug & DS_DBG_FLAG_MD) cmn_err 532 #define DS_DBG_USR if (ds_debug & DS_DBG_FLAG_USR) cmn_err 533 #define DS_DBG_VLDS if (ds_debug & DS_DBG_FLAG_VLDS) cmn_err 534 #define DS_DBG_PRCL if (ds_debug & DS_DBG_FLAG_PRCL) cmn_err 535 #define DS_DBG_RCVQ if (ds_debug & DS_DBG_FLAG_RCVQ) cmn_err 536 #define DS_DBG_LOOP if (ds_debug & DS_DBG_FLAG_LOOP) cmn_err 537 538 #define DS_DUMP_MSG(flags, buf, len) if (ds_debug & (flags)) \ 539 ds_dump_msg(buf, len) 540 541 extern uint_t ds_debug; 542 void ds_dump_msg(void *buf, size_t len); 543 544 #define DS_BADHDL1 (ds_svc_hdl_t)(0xdeadbed1deadbed1ull) 545 #define DS_BADHDL2 (ds_svc_hdl_t)(0x2deadbed2deadbedull) 546 547 #else /* DEBUG */ 548 549 #define DS_DBG if (0) cmn_err 550 #define DS_DBG_LDC DS_DBG 551 #define DS_DBG_LOG DS_DBG 552 #define DS_DBG_MD DS_DBG 553 #define DS_DBG_USR DS_DBG 554 #define DS_DBG_VLDS DS_DBG 555 #define DS_DBG_PRCL DS_DBG 556 #define DS_DBG_RCVQ DS_DBG 557 #define DS_DBG_LOOP DS_DBG 558 #define DS_DUMP_MSG(flags, buf, len) 559 #define DS_DUMP_LDC_MSG(buf, len) 560 561 #define DS_BADHDL1 (ds_svc_hdl_t)0 562 #define DS_BADHDL2 (ds_svc_hdl_t)0 563 564 #endif /* DEBUG */ 565 566 #ifdef __cplusplus 567 } 568 #endif 569 570 #endif /* _DS_IMPL_H */ 571