Changeset 2e39656 in mainline

Timestamp:

2012-07-14T17:41:01Z (12 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

ceafd1b

Parents:

ef5be68

Message:

Check for log readers in separate fibril

Do not even try to send when no reader was announced.

Location:

uspace

Files:

• lib/c/generic/io/log.c (modified) (4 diffs)
• lib/c/include/ipc/logger.h (modified) (1 diff)
• srv/logger/logger.h (modified) (1 diff)
• srv/logger/namespace.c (modified) (4 diffs)

uspace/lib/c/generic/io/log.c

@@ -52 +52 @@
 #define MESSAGE_BUFFER_SIZE 4096
 
+FIBRIL_RWLOCK_INITIALIZE(current_observed_level_lock);
+log_level_t current_observed_level;
+
 static int logger_register(async_sess_t *session, const char *prog_name)
 {
@@ -101 +104 @@
 }
 
+static void cannot_use_level_changed_monitor(void)
+{
+        assert(false && "not implemented yet");
+}
+
+static int observed_level_changed_monitor(void *arg)
+{
+        async_sess_t *monitor_session = service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_LOGGER, LOGGER_INTERFACE_SINK, 0);
+        if (monitor_session == NULL) {
+                cannot_use_level_changed_monitor();
+                return ENOMEM;
+        }
+
+        int rc = logger_register(monitor_session, log_prog_name);
+        if (rc != EOK) {
+                cannot_use_level_changed_monitor();
+                return rc;
+        }
+
+        async_exch_t *exchange = async_exchange_begin(monitor_session);
+        if (exchange == NULL) {
+                cannot_use_level_changed_monitor();
+                return ENOMEM;
+        }
+
+        while (true) {
+                sysarg_t has_reader;
+                sysarg_t msg_rc = async_req_0_1(exchange,
+                    LOGGER_BLOCK_UNTIL_READER_CHANGED, &has_reader);
+                if (msg_rc != EOK) {
+                        cannot_use_level_changed_monitor();
+                        break;
+                }
+
+                fibril_rwlock_write_lock(&current_observed_level_lock);
+                if ((bool) has_reader) {
+                        current_observed_level = LVL_LIMIT;
+                } else {
+                        current_observed_level = LVL_NOTE;
+                }
+                fibril_rwlock_write_unlock(&current_observed_level_lock);
+        }
+
+        async_exchange_end(exchange);
+
+        return EOK;
+}
+
+static log_level_t get_current_observed_level(void)
+{
+        fibril_rwlock_read_lock(&current_observed_level_lock);
+        log_level_t level = current_observed_level;
+        fibril_rwlock_read_unlock(&current_observed_level_lock);
+        return level;
+}
+
 /** Initialize the logging system.
  *
@@ -120 +179 @@
 
         int rc = logger_register(logger_session, log_prog_name);
+
+        current_observed_level = LVL_NOTE;
+
+        fid_t observed_level_changed_fibril = fibril_create(observed_level_changed_monitor, NULL);
+        if (observed_level_changed_fibril == 0) {
+                cannot_use_level_changed_monitor();
+        } else {
+                fibril_add_ready(observed_level_changed_fibril);
+        }
 
         return rc;
@@ -151 +219 @@
         assert(level < LVL_LIMIT);
 
+        if (get_current_observed_level() < level) {
+                return;
+        }
+
         char *message_buffer = malloc(MESSAGE_BUFFER_SIZE);
         if (message_buffer == NULL) {

uspace/lib/c/include/ipc/logger.h

@@ -38 +38 @@
 typedef enum {
         LOGGER_REGISTER = IPC_FIRST_USER_METHOD,
-        LOGGER_MESSAGE
+        LOGGER_MESSAGE,
+        LOGGER_BLOCK_UNTIL_READER_CHANGED
 } logger_sink_request_t;
 

uspace/srv/logger/logger.h

@@ -66 +66 @@
 void namespace_writer_detach(logging_namespace_t *);
 
+void namespace_wait_for_reader_change(logging_namespace_t *, bool *);
 bool namespace_has_reader(logging_namespace_t *);
 void namespace_add_message(logging_namespace_t *, const char *, log_level_t);

uspace/srv/logger/namespace.c

@@ -43 +43 @@
         fibril_mutex_t guard;
         size_t writers_count;
+        fibril_condvar_t reader_appeared_cv;
         bool has_reader;
         const char *name;
@@ -167 +168 @@
                 fibril_mutex_lock(&namespace->guard);
                 namespace->has_reader = true;
+                fibril_condvar_broadcast(&namespace->reader_appeared_cv);
                 fibril_mutex_unlock(&namespace->guard);
         }
@@ -200 +202 @@
         fibril_mutex_lock(&namespace->guard);
         namespace->has_reader = false;
+        fibril_condvar_broadcast(&namespace->reader_appeared_cv);
         fibril_mutex_unlock(&namespace->guard);
 
@@ -221 +224 @@
         fibril_mutex_unlock(&namespace->guard);
         return has_reader;
+}
+
+void namespace_wait_for_reader_change(logging_namespace_t *namespace, bool *has_reader_now)
+{
+        fibril_mutex_lock(&namespace->guard);
+        bool had_reader = namespace->has_reader;
+        while (had_reader == namespace->has_reader) {
+                fibril_condvar_wait(&namespace->reader_appeared_cv, &namespace->guard);
+        }
+        *has_reader_now = namespace->has_reader;
+        fibril_mutex_unlock(&namespace->guard);
 }