1 /*

     2  * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    24 #include "precompiled.hpp"

    25 #include "logging/logLevel.hpp"

    26 #include "logging/logOutputList.hpp"

    27 #include "memory/allocation.inline.hpp"

    28 #include "runtime/atomic.inline.hpp"

    29 #include "runtime/orderAccess.inline.hpp"

    30 #include "utilities/globalDefinitions.hpp"

    31 

    32 jint LogOutputList::increase_readers() {

    33   jint result = Atomic::add(1, &_active_readers);

    34   assert(_active_readers > 0, "Ensure we have consistent state");

    35   return result;

    36 }

    37 

    38 jint LogOutputList::decrease_readers() {

    39   jint result = Atomic::add(-1, &_active_readers);

    40   assert(result >= 0, "Ensure we have consistent state");

    41   return result;

    42 }

    43 

    44 void LogOutputList::wait_until_no_readers() const {

    45   OrderAccess::storeload();

    46   while (_active_readers != 0) {

    47     // Busy wait

    48   }

    49 }

    50 

    51 void LogOutputList::set_output_level(LogOutput* output, LogLevelType level) {

    52   LogOutputNode* node = find(output);

    53   if (level == LogLevel::Off && node != NULL) {

    54     remove_output(node);

    55   } else if (level != LogLevel::Off && node == NULL) {

    56     add_output(output, level);

    57   } else if (node != NULL) {

    58     update_output_level(node, level);

    59   }

    60 }

    61 

    62 LogOutputList::LogOutputNode* LogOutputList::find(LogOutput* output) {

    63   for (LogOutputNode* node = _level_start[LogLevel::Last]; node != NULL; node = node->_next) {

    64     if (output == node->_value) {

    65       return node;

    66     }

    67   }

    68   return NULL;

    69 }

    70 

    71 void LogOutputList::remove_output(LogOutputList::LogOutputNode* node) {

    72   assert(node != NULL, "Node must be non-null");

    73 

    74   // Remove node from _level_start first

    75   bool found = false;

    76   for (uint level = LogLevel::First; level < LogLevel::Count; level++) {

    77     if (_level_start[level] == node) {

    78       found = true;

    79       _level_start[level] = node->_next;

    80     }

    81   }

    82 

    83   // Now remove it from the linked list

    84   for (LogOutputNode* cur = _level_start[LogLevel::Last]; cur != NULL; cur = cur->_next) {

    85     if (cur->_next == node) {

    86       found = true;

    87       cur->_next = node->_next;

    88       break;

    89     }

    90   }

    91   assert(found, "Node to be removed should always be found");

    92 

    93   wait_until_no_readers();

    94   delete node;

    95 }

    96 

    97 void LogOutputList::add_output(LogOutput* output, LogLevelType level) {

    98   LogOutputNode* node = new LogOutputNode();

    99   node->_value = output;

   100   node->_level = level;

   101 

   102   // Set the next pointer to the first node of a lower level

   103   for (node->_next = _level_start[level];

   104        node->_next != NULL && node->_next->_level == level;

   105        node->_next = node->_next->_next) {

   106   }

   107 

   108   // Update the _level_start index

   109   for (int l = LogLevel::Last; l >= level; l--) {

   110     if (_level_start[l] == NULL || _level_start[l]->_level < level) {

   111       _level_start[l] = node;

   112     }

   113   }

   114 

   115   // Add the node the list

   116   for (LogOutputNode* cur = _level_start[LogLevel::Last]; cur != NULL; cur = cur->_next) {

   117     if (cur != node && cur->_next == node->_next) {

   118       cur->_next = node;

   119       break;

   120     }

   121   }

   122 }

   123 

   124 void LogOutputList::update_output_level(LogOutputList::LogOutputNode* node, LogLevelType level) {

   125   add_output(node->_value, level);

   126   wait_until_no_readers();

   127   remove_output(node);

   128 }