emlxs_msg.c revision 8f23e9fa8abcb5857661066b954e63400d589b65
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at
* http://www.opensource.org/licenses/cddl1.txt.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright (c) 2004-2012 Emulex. All rights reserved.
* Use is subject to license terms.
*/
#define DEF_MSG_STRUCT /* Needed for emlxs_messages.h in emlxs_msg.h */
#include <emlxs.h>
uint32_t emlxs_log_size = 2048;
uint32_t emlxs_log_debugs = 0x7FFFFFFF;
uint32_t emlxs_log_notices = 0xFFFFFFFF;
uint32_t emlxs_log_warnings = 0xFFFFFFFF;
uint32_t emlxs_log_errors = 0xFFFFFFFF;
static uint32_t emlxs_msg_log_check(emlxs_port_t *port, emlxs_msg_t *msg);
static uint32_t emlxs_msg_print_check(emlxs_port_t *port, emlxs_msg_t *msg);
static void emlxs_msg_sprintf(char *buffer, emlxs_msg_entry_t *entry);
uint32_t
emlxs_msg_log_create(emlxs_hba_t *hba)
{
emlxs_msg_log_t *log = &LOG;
uint32_t size = sizeof (emlxs_msg_entry_t) * emlxs_log_size;
ddi_iblock_cookie_t iblock;
/* Check if log is already created */
if (log->entry) {
cmn_err(CE_WARN, "?%s%d: message log already created. log=%p",
DRIVER_NAME, hba->ddiinst, (void *)log);
return (0);
}
/* Clear the log */
bzero(log, sizeof (emlxs_msg_log_t));
/* Allocate the memory needed for the log file */
log->entry = (emlxs_msg_entry_t *)kmem_zalloc(size, KM_SLEEP);
/* Initialize */
log->size = emlxs_log_size;
log->instance = hba->ddiinst;
log->start_time = emlxs_device.log_timestamp;
if (!(hba->intr_flags & EMLXS_MSI_ENABLED)) {
/* Get the current interrupt block cookie */
(void) ddi_get_iblock_cookie(hba->dip, (uint_t)EMLXS_INUMBER,
&iblock);
/* Create the log mutex lock */
mutex_init(&log->lock, NULL, MUTEX_DRIVER, (void *)iblock);
}
#ifdef MSI_SUPPORT
else {
/* Create the temporary log mutex lock */
mutex_init(&log->lock, NULL, MUTEX_DRIVER, NULL);
}
#endif
return (1);
} /* emlxs_msg_log_create() */
void
emlxs_msg_lock_reinit(emlxs_hba_t *hba)
{
emlxs_msg_log_t *log = &LOG;
/* Check if log is already destroyed */
if (!log->entry) {
cmn_err(CE_WARN,
"?%s%d: message log already destroyed. log=%p",
DRIVER_NAME, hba->ddiinst, (void *)log);
return;
}
/* Destroy the temporary lock */
mutex_destroy(&log->lock);
/* Re-create the log mutex lock */
mutex_init(&log->lock, NULL, MUTEX_DRIVER, DDI_INTR_PRI(hba->intr_arg));
return;
} /* emlxs_msg_lock_reinit() */
void
emlxs_msg_log_destroy(emlxs_hba_t *hba)
{
emlxs_msg_log_t *log = &LOG;
uint32_t size;
/* Check if log is already destroyed */
if (!log->entry) {
cmn_err(CE_WARN,
"?%s%d: message log already destroyed. log=%p",
DRIVER_NAME, hba->ddiinst, (void *)log);
return;
}
/* Destroy the lock */
mutex_destroy(&log->lock);
/* Free the log buffer */
size = sizeof (emlxs_msg_entry_t) * log->size;
kmem_free(log->entry, size);
/* Clear the log */
bzero(log, sizeof (emlxs_msg_log_t));
return;
} /* emlxs_msg_log_destroy() */
uint32_t
emlxs_msg_log(emlxs_port_t *port, const uint32_t fileno, const uint32_t line,
emlxs_msg_t *msg, char *buffer)
{
emlxs_hba_t *hba = HBA;
emlxs_msg_entry_t *entry;
emlxs_msg_entry_t *entry2;
clock_t time;
emlxs_msg_log_t *log;
uint32_t last;
emlxs_msg_t *msg2;
/* Get the log file for this instance */
log = &LOG;
/* Check if log is initialized */
if (log->entry == NULL) {
return (0);
}
mutex_enter(&log->lock);
/* Get the pointer to the last log entry */
if (log->next == 0) {
last = log->size - 1;
} else {
last = log->next - 1;
}
entry = &log->entry[last];
/* Check if this matches the last message */
if ((entry->instance == log->instance) &&
(entry->vpi == port->vpi) &&
(entry->fileno == fileno) &&
(entry->line == line) &&
(entry->msg == msg) &&
(strcmp(entry->buffer, buffer) == 0)) {
/* If the same message is being logged then increment */
log->repeat++;
mutex_exit(&log->lock);
return (0);
} else if (log->repeat) {
/* Get the pointer to the next log entry */
entry2 = &log->entry[log->next];
/* Increment and check the next entry index */
if (++(log->next) >= log->size) {
log->next = 0;
}
switch (entry->msg->level) {
case EMLXS_NOTICE:
msg2 = &emlxs_notice_msg;
break;
case EMLXS_WARNING:
msg2 = &emlxs_warning_msg;
break;
case EMLXS_ERROR:
msg2 = &emlxs_error_msg;
break;
case EMLXS_PANIC:
msg2 = &emlxs_panic_msg;
break;
case EMLXS_DEBUG:
default:
msg2 = &emlxs_debug_msg;
break;
}
/* Initialize */
entry2->id = log->count++;
entry2->fileno = entry->fileno;
entry2->line = entry->line;
entry2->msg = msg2;
entry2->instance = log->instance;
entry2->vpi = port->vpi;
/* Save the additional info buffer */
(void) snprintf(entry2->buffer, MAX_LOG_INFO_LENGTH,
"Last message repeated %d time(s).",
log->repeat);
/* Set the entry time stamp */
(void) drv_getparm(LBOLT, &time);
entry2->time = time - log->start_time;
gethrestime(&entry2->id_time);
log->repeat = 0;
}
/* Get the pointer to the next log entry */
entry = &log->entry[log->next];
/* Increment and check the next entry index */
if (++(log->next) >= log->size) {
log->next = 0;
}
/* Initialize */
entry->id = log->count++;
entry->fileno = fileno;
entry->line = line;
entry->msg = msg;
entry->instance = log->instance;
entry->vpi = port->vpi;
/* Save the additional info buffer */
(void) strncpy(entry->buffer, buffer, (MAX_LOG_INFO_LENGTH - 1));
entry->buffer[MAX_LOG_INFO_LENGTH - 1] = 0;
/* Set the entry time stamp */
(void) drv_getparm(LBOLT, &time);
entry->time = time - log->start_time;
gethrestime(&entry->id_time);
mutex_exit(&log->lock);
return (0);
} /* emlxs_msg_log() */
/*ARGSUSED*/
static uint32_t
emlxs_msg_log_check(emlxs_port_t *port, emlxs_msg_t *msg)
{
switch (msg->level) {
case EMLXS_DEBUG:
if (msg->mask & emlxs_log_debugs) {
return (1);
}
break;
case EMLXS_NOTICE:
if (msg->mask & emlxs_log_notices) {
return (1);
}
break;
case EMLXS_WARNING:
if (msg->mask & emlxs_log_warnings) {
return (1);
}
break;
case EMLXS_ERROR:
if (msg->mask & emlxs_log_errors) {
return (1);
}
break;
case EMLXS_PANIC:
return (1);
}
return (0);
} /* emlxs_msg_log_check() */
static uint32_t
emlxs_msg_print_check(emlxs_port_t *port, emlxs_msg_t *msg)
{
emlxs_hba_t *hba = HBA;
emlxs_config_t *cfg;
uint32_t rval = 0;
cfg = &CFG;
switch (msg->level) {
case EMLXS_DEBUG:
if (msg->mask & cfg[CFG_CONSOLE_DEBUGS].current) {
rval |= 2;
}
if (msg->mask & cfg[CFG_LOG_DEBUGS].current) {
rval |= 1;
}
break;
case EMLXS_NOTICE:
if (msg->mask & cfg[CFG_CONSOLE_NOTICES].current) {
rval |= 2;
}
if (msg->mask & cfg[CFG_LOG_NOTICES].current) {
rval |= 1;
}
break;
case EMLXS_WARNING:
if (msg->mask & cfg[CFG_CONSOLE_WARNINGS].current) {
rval |= 2;
}
if (msg->mask & cfg[CFG_LOG_WARNINGS].current) {
rval |= 1;
}
break;
case EMLXS_ERROR:
if (msg->mask & cfg[CFG_CONSOLE_ERRORS].current) {
rval |= 2;
}
if (msg->mask & cfg[CFG_LOG_ERRORS].current) {
rval |= 1;
}
break;
case EMLXS_PANIC:
default:
rval |= 1;
}
return (rval);
} /* emlxs_msg_print_check() */
void
emlxs_msg_printf(emlxs_port_t *port, const uint32_t fileno,
const uint32_t line, emlxs_msg_t *msg,
const char *fmt, ...)
{
emlxs_hba_t *hba = HBA;
va_list valist;
char va_str[256];
char msg_str[512];
char *level;
int32_t cmn_level;
uint32_t rval;
char driver[32];
va_str[0] = 0;
if (fmt) {
va_start(valist, fmt);
(void) vsnprintf(va_str, sizeof (va_str), fmt, valist);
va_end(valist);
}
#ifdef FMA_SUPPORT
if (msg->fm_ereport_code) {
emlxs_fm_ereport(hba, msg->fm_ereport_code);
}
if (msg->fm_impact_code) {
emlxs_fm_service_impact(hba, msg->fm_impact_code);
}
#endif /* FMA_SUPPORT */
/* Check if msg should be logged */
if (emlxs_msg_log_check(port, msg)) {
/* Log the message */
if (emlxs_msg_log(port, fileno, line, msg, va_str)) {
return;
}
}
/* Check if msg should be printed */
if (rval = emlxs_msg_print_check(port, msg)) {
cmn_level = CE_CONT;
switch (msg->level) {
case EMLXS_DEBUG:
level = " DEBUG";
break;
case EMLXS_NOTICE:
level = " NOTICE";
break;
case EMLXS_WARNING:
level = "WARNING";
break;
case EMLXS_ERROR:
level = " ERROR";
break;
case EMLXS_PANIC:
cmn_level = CE_PANIC;
level = " PANIC";
break;
default:
level = "UNKNOWN";
break;
}
if (port->vpi == 0) {
(void) snprintf(driver, sizeof (driver), "%s%d",
DRIVER_NAME, hba->ddiinst);
} else {
(void) snprintf(driver, sizeof (driver), "%s%d.%d",
DRIVER_NAME, hba->ddiinst, port->vpi);
}
/* Generate the message string */
if (msg->buffer[0] != 0) {
if (va_str[0] != 0) {
(void) snprintf(msg_str, sizeof (msg_str),
"[%2X.%04X]%s:%7s:%4d: %s (%s)\n", fileno,
line, driver, level, msg->id, msg->buffer,
va_str);
} else {
(void) snprintf(msg_str, sizeof (msg_str),
"[%2X.%04X]%s:%7s:%4d: %s\n",
fileno, line, driver, level, msg->id,
msg->buffer);
}
} else {
if (va_str[0] != 0) {
(void) snprintf(msg_str, sizeof (msg_str),
"[%2X.%04X]%s:%7s:%4d: (%s)\n", fileno,
line, driver, level, msg->id, va_str);
} else {
(void) snprintf(msg_str, sizeof (msg_str),
"[%2X.%04X]%s:%7s:%4d\n",
fileno, line, driver, level, msg->id);
}
}
switch (rval) {
case 1: /* MESSAGE LOG ONLY */
/* Message log & console, if system booted in */
/* verbose mode (CE_CONT only) */
cmn_err(cmn_level, "?%s", msg_str);
break;
case 2: /* CONSOLE ONLY */
cmn_err(cmn_level, "^%s", msg_str);
break;
case 3: /* CONSOLE AND MESSAGE LOG */
cmn_err(cmn_level, "%s", msg_str);
break;
}
}
return;
} /* emlxs_msg_printf() */
uint32_t
emlxs_msg_log_get(emlxs_hba_t *hba, emlxs_log_req_t *req,
emlxs_log_resp_t *resp)
{
emlxs_msg_log_t *log;
uint32_t first;
uint32_t last;
uint32_t count;
uint32_t index;
uint32_t i;
char *resp_buf;
log = &LOG;
mutex_enter(&log->lock);
/* Check if buffer is empty */
if (log->count == 0) {
/* If so, exit now */
resp->first = 0;
resp->last = 0;
resp->count = 0;
mutex_exit(&log->lock);
return (1);
}
/* Get current log entry ranges */
/* Get last entry id saved */
last = log->count - 1;
/* Check if request is out of current range */
if (req->first > last) {
/* if so, exit now */
resp->first = last;
resp->last = last;
resp->count = 0;
mutex_exit(&log->lock);
return (0);
}
/* Get oldest entry id and its index */
/* Check if buffer has already been filled once */
if (log->count >= log->size) {
first = log->count - log->size;
index = log->next;
} else { /* Buffer not yet filled */
first = 0;
index = 0;
}
/* Check if requested first message is greater than actual. */
/* If so, adjust for it. */
if (req->first > first) {
/* Adjust entry index to first requested message */
index += (req->first - first);
if (index >= log->size) {
index -= log->size;
}
first = req->first;
}
/* Get the total number of messages available for return */
count = last - first + 1;
/* Check if requested count is less than actual. If so, adjust it. */
if (req->count < count) {
count = req->count;
}
/* Fill in the response header */
resp->count = count;
resp->first = first;
resp->last = last;
/* Fill the response buffer */
resp_buf = (char *)resp + sizeof (emlxs_log_resp_t);
for (i = 0; i < count; i++) {
emlxs_msg_sprintf(resp_buf, &log->entry[index]);
/* Increment the response buffer */
resp_buf += MAX_LOG_MSG_LENGTH;
/* Increment index */
if (++index >= log->size) {
index = 0;
}
}
mutex_exit(&log->lock);
return (1);
} /* emlxs_msg_log_get() */
static void
emlxs_msg_sprintf(char *buffer, emlxs_msg_entry_t *entry)
{
char *level;
emlxs_msg_t *msg;
uint32_t secs;
uint32_t hsecs;
char buf[256];
uint32_t buflen;
char driver[32];
msg = entry->msg;
hsecs = (entry->time % 100);
secs = entry->time / 100;
switch (msg->level) {
case EMLXS_DEBUG:
level = " DEBUG";
break;
case EMLXS_NOTICE:
level = " NOTICE";
break;
case EMLXS_WARNING:
level = "WARNING";
break;
case EMLXS_ERROR:
level = " ERROR";
break;
case EMLXS_PANIC:
level = " PANIC";
break;
default:
level = "UNKNOWN";
break;
}
if (entry->vpi == 0) {
(void) snprintf(driver, sizeof (driver), "%s%d", DRIVER_NAME,
entry->instance);
} else {
(void) snprintf(driver, sizeof (driver), "%s%d.%d", DRIVER_NAME,
entry->instance, entry->vpi);
}
/* Generate the message string */
if (msg->buffer[0] != 0) {
if (entry->buffer[0] != 0) {
(void) snprintf(buf, sizeof (buf),
"%8d.%02d: %6d:[%2X.%04X]%s:%7s:%4d: %s (%s)\n",
secs, hsecs, entry->id, entry->fileno,
entry->line, driver, level, msg->id, msg->buffer,
entry->buffer);
} else {
(void) snprintf(buf, sizeof (buf),
"%8d.%02d: %6d:[%2X.%04X]%s:%7s:%4d: %s\n", secs,
hsecs, entry->id, entry->fileno, entry->line,
driver, level, msg->id, msg->buffer);
}
} else {
if (entry->buffer[0] != 0) {
(void) snprintf(buf, sizeof (buf),
"%8d.%02d: %6d:[%2X.%04X]%s:%7s:%4d: (%s)\n",
secs, hsecs, entry->id, entry->fileno,
entry->line, driver, level, msg->id,
entry->buffer);
} else {
(void) snprintf(buf, sizeof (buf),
"%8d.%02d: %6d:[%2X.%04X]%s:%7s:%4d\n",
secs, hsecs, entry->id, entry->fileno,
entry->line, driver, level, msg->id);
}
}
bzero(buffer, MAX_LOG_MSG_LENGTH);
buflen = strlen(buf);
if (buflen > (MAX_LOG_MSG_LENGTH - 1)) {
(void) strncpy(buffer, buf, (MAX_LOG_MSG_LENGTH - 2));
buffer[MAX_LOG_MSG_LENGTH - 2] = '\n';
} else {
(void) strncpy(buffer, buf, buflen);
}
return;
} /* emlxs_msg_sprintf() */