drlvm/modules/vm/src/main/native/port/shared/logger/logger.cpp - harmony - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
 #include <apr_env.h>
 #include <apr_portable.h>
 #include <time.h>
 #include "logger.h"
 #include "port_atomic.h"
 #include "hyport.h"

 /**
  * A hook for <code>int vfprintf(va_list)</code> function.
  */
 typedef int (*VfprintfHook)(FILE *fp, const char *format,  va_list args);

 /**
  * A hook for <code>void exit(int)</code> function.
  */
 typedef void (*ExitHook)(int code);

 /**
  * A hook for <code>void abort()</code> function.
  */
 typedef void (*AbortHook)();

 struct LogCategory {
     const char* name;
     int len;
     LogState enabled;
     struct LogCategory* next;
 };

 /**
  * Keeps a logger instance.
  */
 struct Logger {
     /**
      * Serves as a primary source for a dynamic memory allocation.
      */
     apr_pool_t* pool;

     /**
      * A pointer to vfprintf implementation. This pointer may be received via
      * JNI_CreateJavaVM arguments and is used as a base for all VM
      * logging. A static pointer is used when a logger instance cannot be
      * accessed.
      */
     VfprintfHook p_vfprintf;

     /**
      * A pointer to exit implementation. This pointer may be received via
      * JNI_CreateJavaVM arguments and is used for VM graceful termination.
      */
     ExitHook p_exit;

     /**
      * A pointer to abort implementation. This pointer may be received via
      * JNI_CreateJavaVM arguments and is used for abnormal VM termination.
      */
     AbortHook p_abort;

     /**
      * A file to write log, <code>stdout</code> by default.
      */
     FILE* out;

     /**
      * A reference to localization library.
      */
     struct HyPortLibrary* portlib;

     /**
      * Format mask.
      */
     LogFormat format;

     /**
      * A head of a list of enabled info domains.
      */
     struct LogCategory* info;

     /**
      * A head of a list of enabled trace domains.
      */
     struct LogCategory* trace;

     /**
      * A head of a list of encountered log sites.
      */
     struct LogSite* log_site;
 }  light_logger = {
     NULL, &vfprintf, &exit, &abort, stdout, NULL, LOG_EMPTY, NULL, NULL, NULL };

 Logger default_logger = {
     NULL, &vfprintf, &exit, &abort, stdout, NULL, LOG_EMPTY, NULL, NULL, NULL };

 static Logger* get()
 {
     return &default_logger;
 }

 /**
  * Clears cached sites. If more sites are added in process from
  * other threads, they won't be cleared.
  */
 static void clear_cached_sites()
 {
     LogSite *site = get()->log_site;
     while(site) {
         site->state = LOG_UNKNOWN;
         site = site->next;
     }
 }

 static int add_category(const char* category, LogCategory** p_log_category_head,
                         int copy, LogState enabled)
 {
     Logger* logger = get();
     if (!logger->pool) {
         return 0;
     }

     LogCategory* log_category = *p_log_category_head;
     while (log_category) {
         if (strcmp(log_category->name, category) == 0) {
             if (log_category->enabled == enabled) {
                 return 0;
             }
             log_category->enabled = enabled;
             clear_cached_sites();
             return 1;
         }
         log_category = log_category->next;
     }

     log_category = (LogCategory*) apr_palloc(logger->pool, sizeof(LogCategory));
     if (!log_category) {
         return 0;
     }

     log_category->len = (int) strlen(category);
     log_category->enabled = enabled;
     if (copy) {
         char* name = (char*) apr_palloc(logger->pool, log_category->len + 1);
         if (!name) {
             return 0;
         }
         strncpy(name, category, log_category->len + 1);
         log_category->name = name;
     } else {
         log_category->name = category;
     }

     LogCategory* old_value = *p_log_category_head;
     do {
         log_category->next = (LogCategory*) old_value;
         old_value = (LogCategory*) port_atomic_casptr(
             (volatile void **) p_log_category_head, log_category,
             log_category->next);
     } while (old_value != log_category->next);

     clear_cached_sites();
     return 1;
 }

 int log_enable_info_category(const char* category, int copy)
 {
     return add_category(category, &get()->info, copy, LOG_ENABLED);
 }

 int log_enable_trace_category(const char* category, int copy)
 {
     return add_category(category, &get()->trace, copy, LOG_ENABLED);
 }

 int log_disable_info_category(const char* category, int copy)
 {
     return add_category(category, &get()->info, copy, LOG_DISABLED);
 }

 int log_disable_trace_category(const char* category, int copy)
 {
     return add_category(category, &get()->trace, copy, LOG_DISABLED);
 }

 void log_init(apr_pool_t* parent_pool)
 {
     apr_pool_t *pool;
     apr_status_t status = apr_pool_create(&pool, parent_pool);
     if (APR_SUCCESS != status) {
         return;
     }

     Logger* logger = get();
     *logger = light_logger;
     logger->pool = pool;

     log_enable_info_category(LOG_INFO, 0);
 }

 static void log_close()
 {
     Logger* logger = (Logger*) get();
     if (stdout != logger->out) {
         fclose(logger->out);
         logger->out = stdout;
     }
 }

 void log_shutdown()
 {
     Logger* logger = (Logger*) get();
     apr_pool_t* pool = logger->pool;
     log_close();
     *logger = light_logger;
     clear_cached_sites();
     apr_pool_destroy(pool);
 }

 /**
  * Parses locale.
  */
 static int set_locale(const char* logger_locale)
 {
     HyPortLibrary* portlib = get()->portlib;
     assert(portlib);

     char* lang = strdup(logger_locale);
     if (NULL == lang) {
         return 0; // out of C heap
     }
     char* region = NULL;
     char* variant = NULL;

     char* pos = strchr(lang, '_');
     if (pos == NULL) {
         goto set;
     }
     region = pos;
     region[0] = 0;
     region++;

     pos = strchr(region, '.');
     if (pos == NULL) {
         goto set;
     }
     variant = pos;
     variant[0] = 0;
     variant++;

 set:
     portlib->nls_set_locale(portlib, lang, region ? region : "", variant ? variant : "");
     free((void*)lang);
     return 1;
 }

 void log_set_portlib(HyPortLibrary *portlib)
 {
     Logger* logger = get();

     logger->portlib = portlib;
     if (!portlib) {
         return;
     }

     apr_pool_t* tmp_pool;
     apr_status_t status = apr_pool_create(&tmp_pool, logger->pool);
     if (APR_SUCCESS != status) {
         return;
     }
     char* value;
     if (APR_SUCCESS == apr_env_get(&value, "LC_ALL", tmp_pool)) {
         set_locale(value);
     } else if (APR_SUCCESS == apr_env_get(&value, "LC_MESSAGES", tmp_pool)) {
         set_locale(value);
     } else if (APR_SUCCESS == apr_env_get(&value, "LANG", tmp_pool)) {
         set_locale(value);
     }
     apr_pool_destroy(tmp_pool);
 }

 HyPortLibrary* log_get_portlib() {
     return get()->portlib;
 }

 void log_set_vfprintf(void* p_vfprintf)
 {
     get()->p_vfprintf = (VfprintfHook) p_vfprintf;
 }

 void log_set_exit(void* p_exit)
 {
     get()->p_exit = (ExitHook) p_exit;
 }

 void log_set_abort(void* p_abort)
 {
     get()->p_abort = (AbortHook) p_abort;
 }

 void log_set_header_format(LogFormat format)
 {
     get()->format = format;
 }

 void log_set_out(FILE* file)
 {
     log_close();
     get()->out = file;
 }

 APR_DECLARE(void) log_exit(int code)
 {
     log_shutdown();
     get()->p_exit(code);
 }

 APR_DECLARE(void) log_abort()
 {
     log_shutdown();
     assert(0);
     get()->p_abort();
 }

 APR_DECLARE_NONSTD(int) log_printf(const char* format, ...)
 {
     va_list args;
     int ret;

     va_start(args, format);
     ret = get()->p_vfprintf(get()->out, format, args);
     va_end(args);
     fflush(get()->out);
     return ret;
 }

 APR_DECLARE(void) log_header(const char* category, const char* file_line, const char* function_name)
 {
     LogFormat format = get()->format;
     if (format & LOG_THREAD_ID) {
         log_printf("[%p] ", apr_os_thread_current());
     }
     if (format & LOG_TIMESTAMP) {
         log_printf("[%umus] ", (unsigned) clock());
     }
     if (format & LOG_CATEGORY && strcmp(category, LOG_INFO)) {
         log_printf("[%s] ", category);
     }
     if (format & LOG_FUNCTION) {
         log_printf("%s:", file_line);
     }
     if (format & LOG_FILELINE) {
         log_printf("%s:", function_name);
     }
     fflush(get()->out);
 }

 /**
  * Checks if the warnings are enabled.
  */
 APR_DECLARE(LogState) log_is_warn_enabled()
 {
     return (get()->format & LOG_WARN) ? LOG_ENABLED : LOG_DISABLED;
 }

 /**
  * Finds the best matching category in the category list.
  * @return if the category is enabled
  */
 static LogState is_enabled(const char *category, LogCategory *log_category) {
     int max_size = -1;
     LogState enabled = LOG_DISABLED;
     while (log_category) {
         if (strncmp(log_category->name, category, log_category->len) == 0) {
             if (log_category->len > max_size) {
                 max_size = log_category->len;
                 enabled = log_category->enabled;
             }
         }
         log_category = log_category->next;
     }
     return enabled;
 }

 APR_DECLARE(LogState) log_is_info_enabled(const char *category)
 {
     return is_enabled(category, get()->info);
 }

 APR_DECLARE(LogState) log_is_trace_enabled(const char *category)
 {
     return is_enabled(category, get()->trace);
 }

 /**
  * Adds a site to the site list.
  */
 static void add_site(LogSite* log_site) {
     LogSite** p_site_head = (LogSite**) &get()->log_site;
     LogSite* old_value = *p_site_head;
     do {
         log_site->next = (LogSite*) old_value;
         old_value = (LogSite*) port_atomic_casptr(
             (volatile void **) p_site_head, log_site, log_site->next);
     } while (old_value != log_site->next);
 }

 APR_DECLARE(LogState) log_cache(LogState enabled, struct LogSite* p_log_site)
 {
     if(!p_log_site->next) {
         add_site(p_log_site);
     }
     p_log_site->state = enabled ? LOG_ENABLED : LOG_DISABLED;
     return enabled;
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	#include <apr_env.h>
	#include <apr_portable.h>
	#include <time.h>
	#include "logger.h"
	#include "port_atomic.h"
	#include "hyport.h"

	/**
	* A hook for <code>int vfprintf(va_list)</code> function.
	*/
	typedef int (VfprintfHook)(FILE fp, const char *format, va_list args);

	/**
	* A hook for <code>void exit(int)</code> function.
	*/
	typedef void (*ExitHook)(int code);

	/**
	* A hook for <code>void abort()</code> function.
	*/
	typedef void (*AbortHook)();

	struct LogCategory {
	const char* name;
	int len;
	LogState enabled;
	struct LogCategory* next;
	};

	/**
	* Keeps a logger instance.
	*/
	struct Logger {
	/**
	* Serves as a primary source for a dynamic memory allocation.
	*/
	apr_pool_t* pool;

	/**
	* A pointer to vfprintf implementation. This pointer may be received via
	* JNI_CreateJavaVM arguments and is used as a base for all VM
	* logging. A static pointer is used when a logger instance cannot be
	* accessed.
	*/
	VfprintfHook p_vfprintf;

	/**
	* A pointer to exit implementation. This pointer may be received via
	* JNI_CreateJavaVM arguments and is used for VM graceful termination.
	*/
	ExitHook p_exit;

	/**
	* A pointer to abort implementation. This pointer may be received via
	* JNI_CreateJavaVM arguments and is used for abnormal VM termination.
	*/
	AbortHook p_abort;

	/**
	* A file to write log, <code>stdout</code> by default.
	*/
	FILE* out;

	/**
	* A reference to localization library.
	*/
	struct HyPortLibrary* portlib;

	/**
	* Format mask.
	*/
	LogFormat format;

	/**
	* A head of a list of enabled info domains.
	*/
	struct LogCategory* info;

	/**
	* A head of a list of enabled trace domains.
	*/
	struct LogCategory* trace;

	/**
	* A head of a list of encountered log sites.
	*/
	struct LogSite* log_site;
	} light_logger = {
	NULL, &vfprintf, &exit, &abort, stdout, NULL, LOG_EMPTY, NULL, NULL, NULL };

	Logger default_logger = {
	NULL, &vfprintf, &exit, &abort, stdout, NULL, LOG_EMPTY, NULL, NULL, NULL };

	static Logger* get()
	{
	return &default_logger;
	}

	/**
	* Clears cached sites. If more sites are added in process from
	* other threads, they won't be cleared.
	*/
	static void clear_cached_sites()
	{
	LogSite *site = get()->log_site;
	while(site) {
	site->state = LOG_UNKNOWN;
	site = site->next;
	}
	}

	static int add_category(const char* category, LogCategory** p_log_category_head,
	int copy, LogState enabled)
	{
	Logger* logger = get();
	if (!logger->pool) {
	return 0;
	}

	LogCategory* log_category = *p_log_category_head;
	while (log_category) {
	if (strcmp(log_category->name, category) == 0) {
	if (log_category->enabled == enabled) {
	return 0;
	}
	log_category->enabled = enabled;
	clear_cached_sites();
	return 1;
	}
	log_category = log_category->next;
	}

	log_category = (LogCategory*) apr_palloc(logger->pool, sizeof(LogCategory));
	if (!log_category) {
	return 0;
	}

	log_category->len = (int) strlen(category);
	log_category->enabled = enabled;
	if (copy) {
	char* name = (char*) apr_palloc(logger->pool, log_category->len + 1);
	if (!name) {
	return 0;
	}
	strncpy(name, category, log_category->len + 1);
	log_category->name = name;
	} else {
	log_category->name = category;
	}

	LogCategory* old_value = *p_log_category_head;
	do {
	log_category->next = (LogCategory*) old_value;
	old_value = (LogCategory*) port_atomic_casptr(
	(volatile void **) p_log_category_head, log_category,
	log_category->next);
	} while (old_value != log_category->next);

	clear_cached_sites();
	return 1;
	}

	int log_enable_info_category(const char* category, int copy)
	{
	return add_category(category, &get()->info, copy, LOG_ENABLED);
	}

	int log_enable_trace_category(const char* category, int copy)
	{
	return add_category(category, &get()->trace, copy, LOG_ENABLED);
	}

	int log_disable_info_category(const char* category, int copy)
	{
	return add_category(category, &get()->info, copy, LOG_DISABLED);
	}

	int log_disable_trace_category(const char* category, int copy)
	{
	return add_category(category, &get()->trace, copy, LOG_DISABLED);
	}

	void log_init(apr_pool_t* parent_pool)
	{
	apr_pool_t *pool;
	apr_status_t status = apr_pool_create(&pool, parent_pool);
	if (APR_SUCCESS != status) {
	return;
	}

	Logger* logger = get();
	*logger = light_logger;
	logger->pool = pool;

	log_enable_info_category(LOG_INFO, 0);
	}

	static void log_close()
	{
	Logger* logger = (Logger*) get();
	if (stdout != logger->out) {
	fclose(logger->out);
	logger->out = stdout;
	}
	}

	void log_shutdown()
	{
	Logger* logger = (Logger*) get();
	apr_pool_t* pool = logger->pool;
	log_close();
	*logger = light_logger;
	clear_cached_sites();
	apr_pool_destroy(pool);
	}

	/**
	* Parses locale.
	*/
	static int set_locale(const char* logger_locale)
	{
	HyPortLibrary* portlib = get()->portlib;
	assert(portlib);

	char* lang = strdup(logger_locale);
	if (NULL == lang) {
	return 0; // out of C heap
	}
	char* region = NULL;
	char* variant = NULL;

	char* pos = strchr(lang, '_');
	if (pos == NULL) {
	goto set;
	}
	region = pos;
	region[0] = 0;
	region++;

	pos = strchr(region, '.');
	if (pos == NULL) {
	goto set;
	}
	variant = pos;
	variant[0] = 0;
	variant++;

	set:
	portlib->nls_set_locale(portlib, lang, region ? region : "", variant ? variant : "");
	free((void*)lang);
	return 1;
	}

	void log_set_portlib(HyPortLibrary *portlib)
	{
	Logger* logger = get();

	logger->portlib = portlib;
	if (!portlib) {
	return;
	}

	apr_pool_t* tmp_pool;
	apr_status_t status = apr_pool_create(&tmp_pool, logger->pool);
	if (APR_SUCCESS != status) {
	return;
	}
	char* value;
	if (APR_SUCCESS == apr_env_get(&value, "LC_ALL", tmp_pool)) {
	set_locale(value);
	} else if (APR_SUCCESS == apr_env_get(&value, "LC_MESSAGES", tmp_pool)) {
	set_locale(value);
	} else if (APR_SUCCESS == apr_env_get(&value, "LANG", tmp_pool)) {
	set_locale(value);
	}
	apr_pool_destroy(tmp_pool);
	}

	HyPortLibrary* log_get_portlib() {
	return get()->portlib;
	}

	void log_set_vfprintf(void* p_vfprintf)
	{
	get()->p_vfprintf = (VfprintfHook) p_vfprintf;
	}

	void log_set_exit(void* p_exit)
	{
	get()->p_exit = (ExitHook) p_exit;
	}

	void log_set_abort(void* p_abort)
	{
	get()->p_abort = (AbortHook) p_abort;
	}

	void log_set_header_format(LogFormat format)
	{
	get()->format = format;
	}

	void log_set_out(FILE* file)
	{
	log_close();
	get()->out = file;
	}

	APR_DECLARE(void) log_exit(int code)
	{
	log_shutdown();
	get()->p_exit(code);
	}

	APR_DECLARE(void) log_abort()
	{
	log_shutdown();
	assert(0);
	get()->p_abort();
	}

	APR_DECLARE_NONSTD(int) log_printf(const char* format, ...)
	{
	va_list args;
	int ret;

	va_start(args, format);
	ret = get()->p_vfprintf(get()->out, format, args);
	va_end(args);
	fflush(get()->out);
	return ret;
	}

	APR_DECLARE(void) log_header(const char* category, const char* file_line, const char* function_name)
	{
	LogFormat format = get()->format;
	if (format & LOG_THREAD_ID) {
	log_printf("[%p] ", apr_os_thread_current());
	}
	if (format & LOG_TIMESTAMP) {
	log_printf("[%umus] ", (unsigned) clock());
	}
	if (format & LOG_CATEGORY && strcmp(category, LOG_INFO)) {
	log_printf("[%s] ", category);
	}
	if (format & LOG_FUNCTION) {
	log_printf("%s:", file_line);
	}
	if (format & LOG_FILELINE) {
	log_printf("%s:", function_name);
	}
	fflush(get()->out);
	}

	/**
	* Checks if the warnings are enabled.
	*/
	APR_DECLARE(LogState) log_is_warn_enabled()
	{
	return (get()->format & LOG_WARN) ? LOG_ENABLED : LOG_DISABLED;
	}

	/**
	* Finds the best matching category in the category list.
	* @return if the category is enabled
	*/
	static LogState is_enabled(const char category, LogCategory log_category) {
	int max_size = -1;
	LogState enabled = LOG_DISABLED;
	while (log_category) {
	if (strncmp(log_category->name, category, log_category->len) == 0) {
	if (log_category->len > max_size) {
	max_size = log_category->len;
	enabled = log_category->enabled;
	}
	}
	log_category = log_category->next;
	}
	return enabled;
	}

	APR_DECLARE(LogState) log_is_info_enabled(const char *category)
	{
	return is_enabled(category, get()->info);
	}

	APR_DECLARE(LogState) log_is_trace_enabled(const char *category)
	{
	return is_enabled(category, get()->trace);
	}

	/**
	* Adds a site to the site list.
	*/
	static void add_site(LogSite* log_site) {
	LogSite p_site_head = (LogSite) &get()->log_site;
	LogSite* old_value = *p_site_head;
	do {
	log_site->next = (LogSite*) old_value;
	old_value = (LogSite*) port_atomic_casptr(
	(volatile void **) p_site_head, log_site, log_site->next);
	} while (old_value != log_site->next);
	}

	APR_DECLARE(LogState) log_cache(LogState enabled, struct LogSite* p_log_site)
	{
	if(!p_log_site->next) {
	add_site(p_log_site);
	}
	p_log_site->state = enabled ? LOG_ENABLED : LOG_DISABLED;
	return enabled;
	}