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 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* 27 * ibtf_util.c 28 * 29 * This file contains the IBTF module's helper/utility functions. 30 * - IBTF logging support 31 */ 32 33 #include <sys/ib/ibtl/impl/ibtl.h> 34 35 static char ibtf_util[] = "ibtl_util"; 36 37 /* Function Prototypes */ 38 static void ibtf_clear_print_buf(); 39 40 /* 41 * Print Buffer protected by mutex for debug stuff. The mutex also 42 * ensures serializing debug messages. 43 */ 44 static kmutex_t ibtf_print_mutex; 45 static char ibtf_print_buf[IBTL_PRINT_BUF_LEN]; 46 47 /* 48 * Debug Stuff. 49 */ 50 uint_t ibtf_errlevel = IBTF_LOG_L5; 51 uint_t ibgen_errlevel = IBTF_LOG_L2; 52 uint_t ibtl_errlevel = IBTF_LOG_L2; 53 uint_t ibcm_errlevel = IBTF_LOG_L2; 54 uint_t ibdm_errlevel = IBTF_LOG_L2; 55 uint_t ibnex_errlevel = IBTF_LOG_L2; 56 57 #define IBTF_DEBUG_SIZE_EXTRA_ALLOC 8 58 #define IBTF_MIN_DEBUG_BUF_SIZE 0x1000 59 #ifdef DEBUG 60 #define IBTF_DEBUG_BUF_SIZE 0x10000 61 #else 62 #define IBTF_DEBUG_BUF_SIZE 0x2000 63 #endif /* DEBUG */ 64 65 int ibtf_suppress_dprintf; /* Suppress debug printing */ 66 int ibtf_buffer_dprintf = 1; /* Use a debug print buffer */ 67 int ibtf_debug_buf_size = IBTF_DEBUG_BUF_SIZE; /* Sz of Debug buf */ 68 int ibtf_allow_intr_msgs = 0; /* log "intr" messages */ 69 char *ibtf_debug_buf = NULL; /* The Debug Buf */ 70 char *ibtf_buf_sptr, *ibtf_buf_eptr; /* debug buffer temp pointer */ 71 int ibtf_clear_debug_buf_flag = 0; /* Clear debug buffer */ 72 _NOTE(SCHEME_PROTECTS_DATA("inconsistency OK", ibtf_debug_buf_size)) 73 74 longlong_t ibtl_ib2usec_tbl[64]; /* time conversion table */ 75 _NOTE(SCHEME_PROTECTS_DATA("inconsistency OK", ibtl_ib2usec_tbl)) 76 77 _NOTE(MUTEX_PROTECTS_DATA(ibtf_print_mutex, ibtf_buf_sptr ibtf_buf_eptr)) 78 79 /* 80 * Function: 81 * ibtl_ib2usec_init 82 * Input: 83 * none 84 * Output: 85 * none 86 * Returns: 87 * none 88 * Description: 89 * Initialize ibtl_ib2usec_tbl[64] for use by ibt_usec2ib and ibt_ib2usec. 90 */ 91 void 92 ibtl_ib2usec_init(void) 93 { 94 int i; 95 96 for (i = 0; i < 64; i++) { 97 if (i < 51) { /* shift first to avoid underflow */ 98 ibtl_ib2usec_tbl[i] = ((1LL << i) << 12LL) / 1000LL; 99 } else if (i < 61) { /* divide first to avoid overflow */ 100 ibtl_ib2usec_tbl[i] = ((1LL << i) / 1000LL) << 12LL; 101 } else { /* max'ed out, so use MAX LONGLONG */ 102 ibtl_ib2usec_tbl[i] = 0x7FFFFFFFFFFFFFFFLL; 103 } 104 #if !defined(_LP64) 105 if (ibtl_ib2usec_tbl[i] > LONG_MAX) 106 ibtl_ib2usec_tbl[i] = LONG_MAX; 107 #endif 108 } 109 } 110 111 /* 112 * Function: 113 * ibt_usec2ib 114 * Input: 115 * time_val - Time in microsecs. 116 * Output: 117 * none 118 * Returns: 119 * Nearest IB Timeout Exponent value. 120 * Description: 121 * This function converts the standard input time in microseconds to 122 * IB's 6 bits of timeout exponent, calculated based on 123 * time = 4.096us * 2 ^ exp. This is done by searching through 124 * the ibtl_ib2usec_tbl for the closest value >= time_val. 125 */ 126 ib_time_t 127 ibt_usec2ib(clock_t time_val) 128 { 129 int i; 130 131 IBTF_DPRINTF_L3(ibtf_util, "ibt_usec2ib(%ld)", time_val); 132 133 /* First, leap through the table by 4 entries at a time */ 134 for (i = 0; (i + 4) < 64 && ibtl_ib2usec_tbl[i + 4] < time_val; i += 4) 135 ; 136 /* Find the return value; it's now between i and i + 4, inclusive */ 137 while (ibtl_ib2usec_tbl[i] < time_val) 138 i++; 139 return (i); 140 } 141 142 143 /* 144 * Function: 145 * ibt_ib2usec 146 * Input: 147 * ib_time - IB Timeout Exponent value. 148 * Output: 149 * none 150 * Returns: 151 * Standard Time is microseconds. 152 * Description: 153 * This function converts the input IB timeout exponent (6 bits) to 154 * standard time in microseconds, calculated based on 155 * time = 4.096us * 2 ^ exp. 156 * This is implemented as a simple index into ibtl_ib2usec_tbl[]. 157 */ 158 clock_t 159 ibt_ib2usec(ib_time_t ib_time) 160 { 161 IBTF_DPRINTF_L3(ibtf_util, "ibt_ib2usec(%d)", ib_time); 162 163 return ((clock_t)ibtl_ib2usec_tbl[ib_time & IB_TIME_EXP_MASK]); 164 } 165 166 167 /* IBTF logging init */ 168 void 169 ibtl_logging_initialization() 170 { 171 boolean_t flag = B_FALSE; 172 173 IBTF_DPRINTF_L3(ibtf_util, "ibtl_logging_initialization:"); 174 175 mutex_init(&ibtf_print_mutex, NULL, MUTEX_DRIVER, NULL); 176 mutex_enter(&ibtf_print_mutex); 177 178 if (ibtf_debug_buf_size <= IBTF_DEBUG_SIZE_EXTRA_ALLOC) { 179 ibtf_debug_buf_size = IBTF_MIN_DEBUG_BUF_SIZE; 180 flag = B_TRUE; 181 } 182 183 /* if it is less that IBTF_MIN_DEBUG_BUF_SIZE, adjust it */ 184 ibtf_debug_buf_size = max(IBTF_MIN_DEBUG_BUF_SIZE, 185 ibtf_debug_buf_size); 186 187 ibtf_debug_buf = (char *)kmem_alloc(ibtf_debug_buf_size, KM_SLEEP); 188 ibtf_clear_print_buf(); 189 mutex_exit(&ibtf_print_mutex); 190 191 if (flag == B_TRUE) { 192 IBTF_DPRINTF_L2(ibtf_util, "ibtf_debug_buf_size was too small " 193 "%x, adjusted to %x", ibtf_debug_buf_size, 194 IBTF_MIN_DEBUG_BUF_SIZE); 195 } 196 } 197 198 199 /* IBTF logging destroy */ 200 void 201 ibtl_logging_destroy() 202 { 203 IBTF_DPRINTF_L3(ibtf_util, "ibtl_logging_destroy"); 204 205 mutex_enter(&ibtf_print_mutex); 206 if (ibtf_debug_buf) { 207 kmem_free(ibtf_debug_buf, ibtf_debug_buf_size); 208 ibtf_debug_buf = NULL; 209 } 210 mutex_exit(&ibtf_print_mutex); 211 mutex_destroy(&ibtf_print_mutex); 212 } 213 214 215 /* 216 * debug, log, and console message handling 217 */ 218 219 /* 220 * clear the IBTF trace buffer 221 */ 222 static void 223 ibtf_clear_print_buf() 224 { 225 ASSERT(MUTEX_HELD(&ibtf_print_mutex)); 226 if (ibtf_debug_buf) { 227 ibtf_buf_sptr = ibtf_debug_buf; 228 ibtf_buf_eptr = ibtf_debug_buf + ibtf_debug_buf_size - 229 IBTF_DEBUG_SIZE_EXTRA_ALLOC; 230 231 bzero(ibtf_debug_buf, ibtf_debug_buf_size); 232 } 233 } 234 235 236 static void 237 ibtf_vlog(char *name, uint_t level, char *fmt, va_list ap) 238 { 239 char *label = (name == NULL) ? "ibtl" : name; 240 char *msg_ptr; 241 size_t len; 242 243 mutex_enter(&ibtf_print_mutex); 244 245 /* if not using logging scheme; quit */ 246 if (ibtf_suppress_dprintf || (ibtf_debug_buf == NULL)) { 247 mutex_exit(&ibtf_print_mutex); 248 return; 249 } 250 251 /* if level doesn't match, we are done */ 252 if ((level < IBTF_LOG_L0) || (level > IBTF_LOG_LINTR)) { 253 mutex_exit(&ibtf_print_mutex); 254 return; 255 } 256 257 /* If user requests to clear debug buffer, go ahead */ 258 if (ibtf_clear_debug_buf_flag != 0) { 259 ibtf_clear_print_buf(); 260 ibtf_clear_debug_buf_flag = 0; 261 } 262 263 /* 264 * Check if we have a valid buf size? 265 * Suppress logging to ibtf_buffer if so. 266 */ 267 if (ibtf_debug_buf_size <= 0) { 268 ibtf_buffer_dprintf = 0; 269 } 270 271 /* 272 * put "label" into the buffer 273 */ 274 len = snprintf(ibtf_print_buf, IBTL_DRVNAME_LEN, "%s:\t", label); 275 276 msg_ptr = ibtf_print_buf + len; 277 len += vsnprintf(msg_ptr, IBTL_PRINT_BUF_LEN - len - 2, fmt, ap); 278 279 len = min(len, IBTL_PRINT_BUF_LEN - 2); 280 ASSERT(len == strlen(ibtf_print_buf)); 281 ibtf_print_buf[len++] = '\n'; 282 ibtf_print_buf[len] = '\0'; 283 284 /* 285 * stuff the message in the debug buf 286 */ 287 if (ibtf_buffer_dprintf) { 288 289 /* 290 * overwrite >>>> that might be over the end of the 291 * the buffer 292 */ 293 *ibtf_buf_sptr = '\0'; 294 295 if (ibtf_buf_sptr + len > ibtf_buf_eptr) { 296 size_t left = ibtf_buf_eptr - ibtf_buf_sptr; 297 298 bcopy((caddr_t)ibtf_print_buf, 299 (caddr_t)ibtf_buf_sptr, left); 300 bcopy((caddr_t)ibtf_print_buf + left, 301 (caddr_t)ibtf_debug_buf, len - left); 302 ibtf_buf_sptr = ibtf_debug_buf + len - left; 303 } else { 304 bcopy((caddr_t)ibtf_print_buf, ibtf_buf_sptr, len); 305 ibtf_buf_sptr += len; 306 } 307 308 /* add marker */ 309 (void) sprintf(ibtf_buf_sptr, ">>>>"); 310 } 311 312 /* 313 * LINTR, L5-L2 message may go to the ibtf_debug_buf 314 * L1 messages will go to the log buf in non-debug kernels and 315 * to console and log buf in debug kernels 316 * L0 messages are warnings and will go to console and log buf 317 */ 318 switch (level) { 319 case IBTF_LOG_LINTR: 320 case IBTF_LOG_L5: 321 case IBTF_LOG_L4: 322 case IBTF_LOG_L3: 323 case IBTF_LOG_L2: 324 if (!ibtf_buffer_dprintf) { 325 cmn_err(CE_CONT, "^%s", ibtf_print_buf); 326 } 327 break; 328 case IBTF_LOG_L1: 329 #ifdef DEBUG 330 cmn_err(CE_CONT, "%s", ibtf_print_buf); 331 #else 332 if (!ibtf_buffer_dprintf) { 333 cmn_err(CE_CONT, "^%s", ibtf_print_buf); 334 } 335 #endif 336 break; 337 case IBTF_LOG_L0: 338 /* Strip the "\n" added earlier */ 339 if (ibtf_print_buf[len - 1] == '\n') { 340 ibtf_print_buf[len - 1] = '\0'; 341 } 342 if (msg_ptr[len - 1] == '\n') { 343 msg_ptr[len - 1] = '\0'; 344 } 345 cmn_err(CE_WARN, ibtf_print_buf); 346 break; 347 } 348 349 mutex_exit(&ibtf_print_mutex); 350 } 351 352 353 void 354 ibtl_dprintf_intr(char *name, char *fmt, ...) 355 { 356 va_list ap; 357 358 /* only log messages if "ibtf_allow_intr_msgs" is set */ 359 if (!ibtf_allow_intr_msgs) 360 return; 361 362 va_start(ap, fmt); 363 ibtf_vlog(name, IBTF_LOG_LINTR, fmt, ap); 364 va_end(ap); 365 } 366 367 368 /* 369 * Check individual subsystem err levels 370 */ 371 #define IBTL_CHECK_ERR_LEVEL(level) \ 372 if (strncmp(name, "ibgen", 5) == 0) { \ 373 if (ibgen_errlevel < level) \ 374 return; \ 375 } else if (strncmp(name, "ibtl", 4) == 0) { \ 376 if (ibtl_errlevel < level) \ 377 return; \ 378 } else if (strncmp(name, "ibcm", 4) == 0) { \ 379 if (ibcm_errlevel < level) \ 380 return; \ 381 } else if (strncmp(name, "ibdm", 4) == 0) { \ 382 if (ibdm_errlevel < level) \ 383 return; \ 384 } else if (strncmp(name, "ibnex", 5) == 0) { \ 385 if (ibnex_errlevel < level) \ 386 return; \ 387 } 388 389 void 390 ibtl_dprintf5(char *name, char *fmt, ...) 391 { 392 va_list ap; 393 394 /* check if global errlevel matches or not */ 395 if (ibtf_errlevel < IBTF_LOG_L5) 396 return; 397 398 IBTL_CHECK_ERR_LEVEL(IBTF_LOG_L5); 399 400 va_start(ap, fmt); 401 ibtf_vlog(name, IBTF_LOG_L5, fmt, ap); 402 va_end(ap); 403 } 404 405 void 406 ibtl_dprintf4(char *name, char *fmt, ...) 407 { 408 va_list ap; 409 410 /* check if global errlevel matches or not */ 411 if (ibtf_errlevel < IBTF_LOG_L4) 412 return; 413 414 IBTL_CHECK_ERR_LEVEL(IBTF_LOG_L4); 415 416 va_start(ap, fmt); 417 ibtf_vlog(name, IBTF_LOG_L4, fmt, ap); 418 va_end(ap); 419 } 420 421 422 void 423 ibtl_dprintf3(char *name, char *fmt, ...) 424 { 425 va_list ap; 426 427 /* check if global errlevel matches or not */ 428 if (ibtf_errlevel < IBTF_LOG_L3) 429 return; 430 431 IBTL_CHECK_ERR_LEVEL(IBTF_LOG_L3); 432 433 va_start(ap, fmt); 434 ibtf_vlog(name, IBTF_LOG_L3, fmt, ap); 435 va_end(ap); 436 } 437 438 439 void 440 ibtl_dprintf2(char *name, char *fmt, ...) 441 { 442 va_list ap; 443 444 /* check if global errlevel matches or not */ 445 if (ibtf_errlevel < IBTF_LOG_L2) 446 return; 447 448 IBTL_CHECK_ERR_LEVEL(IBTF_LOG_L2); 449 450 va_start(ap, fmt); 451 ibtf_vlog(name, IBTF_LOG_L2, fmt, ap); 452 va_end(ap); 453 } 454 455 456 void 457 ibtl_dprintf1(char *name, char *fmt, ...) 458 { 459 va_list ap; 460 461 /* check if global errlevel matches or not */ 462 if (ibtf_errlevel < IBTF_LOG_L1) 463 return; 464 465 va_start(ap, fmt); 466 ibtf_vlog(name, IBTF_LOG_L1, fmt, ap); 467 va_end(ap); 468 } 469 470 471 /* 472 * Function: 473 * ibtf_dprintf0 474 * Input: 475 * name - Name of the subsystem generating the debug message 476 * fmt - The message to be displayed. 477 * Output: 478 * none 479 * Returns: 480 * none 481 * Description: 482 * A generic log function to display IBTF debug messages. 483 */ 484 void 485 ibtl_dprintf0(char *name, char *fmt, ...) 486 { 487 va_list ap; 488 489 /* check if global errlevel matches or not */ 490 if (ibtf_errlevel < IBTF_LOG_L0) 491 return; 492 493 va_start(ap, fmt); 494 ibtf_vlog(name, IBTF_LOG_L0, fmt, ap); 495 va_end(ap); 496 } 497