Changeset 131d9a4 in mainline

Timestamp:

2012-09-07T07:56:01Z (12 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

70253688

Parents:

b6933f3

Message:

Logger: destroy logs on client disconnect

Location:

uspace/srv/logger

Files:

• initlvl.c (modified) (1 diff)
• logger.h (modified) (3 diffs)
• logs.c (modified) (3 diffs)
• writer.c (modified) (3 diffs)

uspace/srv/logger/initlvl.c

@@ -67 +67 @@
 
         log->logged_level = level;
+        log->ref_counter++;
 
         log_unlock(log);

uspace/srv/logger/logger.h

@@ -58 +58 @@
         link_t link;
 
+        size_t ref_counter;
+
         fibril_mutex_t guard;
 
@@ -67 +69 @@
 };
 
+#define MAX_REFERENCED_LOGS_PER_CLIENT 100
+
+typedef struct {
+        size_t logs_count;
+        logger_log_t *logs[MAX_REFERENCED_LOGS_PER_CLIENT];
+} logger_registered_logs_t;
+
 logger_log_t *find_log_by_name_and_lock(const char *name);
 logger_log_t *find_or_create_log_and_lock(const char *, sysarg_t);
@@ -73 +82 @@
 void log_unlock(logger_log_t *);
 void write_to_log(logger_log_t *, log_level_t, const char *);
+void log_release(logger_log_t *);
+
+void registered_logs_init(logger_registered_logs_t *);
+bool register_log(logger_registered_logs_t *, logger_log_t *);
+void unregister_logs(logger_registered_logs_t *);
 
 log_level_t get_default_logging_level(void);

uspace/srv/logger/logs.c

@@ -128 +128 @@
                         goto leave;
                 list_append(&result->link, &log_list);
+                if (result->parent != NULL) {
+                        fibril_mutex_lock(&result->parent->guard);
+                        result->parent->ref_counter++;
+                        fibril_mutex_unlock(&result->parent->guard);
+                }
         }
 
@@ -200 +205 @@
 }
 
+/** Decreases reference counter on the log and destory the log if
+ * necessary.
+ *
+ * Precondition: log is locked.
+ *
+ * @param log Log to release from using by the caller.
+ */
+void log_release(logger_log_t *log)
+{
+        assert(fibril_mutex_is_locked(&log->guard));
+        assert(log->ref_counter > 0);
+
+        /* We are definitely not the last ones. */
+        if (log->ref_counter > 1) {
+                log->ref_counter--;
+                fibril_mutex_unlock(&log->guard);
+                return;
+        }
+
+        /*
+         * To prevent deadlock, we need to get the list lock first.
+         * Deadlock scenario:
+         * Us: LOCKED(log), want to LOCK(list)
+         * Someone else calls find_log_by_name_and_lock(log->fullname) ->
+         *   LOCKED(list), wants to LOCK(log)
+         */
+        fibril_mutex_unlock(&log->guard);
+
+        /* Ensuring correct locking order. */
+        fibril_mutex_lock(&log_list_guard);
+        /*
+         * The reference must be still valid because we have not decreased
+         * the reference counter.
+         */
+        fibril_mutex_lock(&log->guard);
+        assert(log->ref_counter > 0);
+        log->ref_counter--;
+
+        if (log->ref_counter > 0) {
+                /*
+                 * Meanwhile, someone else increased the ref counter.
+                 * No big deal, we just return immediatelly.
+                 */
+                fibril_mutex_unlock(&log->guard);
+                fibril_mutex_unlock(&log_list_guard);
+                return;
+        }
+
+        /*
+         * Here we are on a destroy path. We need to
+         * - remove ourselves from the list
+         * - decrease reference of the parent (if not top-level log)
+         *   - we must do that after we relaase list lock to prevent
+         *     deadlock with ourselves
+         * - destroy dest (if top-level log)
+         */
+        assert(log->ref_counter == 0);
+
+        list_remove(&log->link);
+        fibril_mutex_unlock(&log_list_guard);
+        fibril_mutex_unlock(&log->guard);
+
+        if (log->parent == NULL) {
+                fclose(log->dest->logfile);
+                free(log->dest->filename);
+                free(log->dest);
+        } else {
+                fibril_mutex_lock(&log->parent->guard);
+                log_release(log->parent);
+        }
+
+        printf("Destroying log %s.\n", log->full_name);
+
+        free(log->name);
+        free(log->full_name);
+
+        free(log);
+}
+
+
 void write_to_log(logger_log_t *log, log_level_t level, const char *message)
 {
@@ -218 +303 @@
 }
 
+void registered_logs_init(logger_registered_logs_t *logs)
+{
+        logs->logs_count = 0;
+}
+
+bool register_log(logger_registered_logs_t *logs, logger_log_t *new_log)
+{
+        if (logs->logs_count >= MAX_REFERENCED_LOGS_PER_CLIENT) {
+                return false;
+        }
+
+        assert(fibril_mutex_is_locked(&new_log->guard));
+        new_log->ref_counter++;
+
+        logs->logs[logs->logs_count] = new_log;
+        logs->logs_count++;
+
+        return true;
+}
+
+void unregister_logs(logger_registered_logs_t *logs)
+{
+        for (size_t i = 0; i < logs->logs_count; i++) {
+                logger_log_t *log = logs->logs[i];
+                fibril_mutex_lock(&log->guard);
+                log_release(log);
+        }
+}
+
 /**
  * @}

uspace/srv/logger/writer.c

@@ -100 +100 @@
         printf(NAME "/writer: new client.\n");
 
+        logger_registered_logs_t registered_logs;
+        registered_logs_init(&registered_logs);
+
         while (true) {
                 ipc_call_t call;
@@ -112 +115 @@
                         if (log == NULL) {
                                 async_answer_0(callid, ENOMEM);
+                                break;
+                        }
+                        if (!register_log(&registered_logs, log)) {
+                                log_unlock(log);
+                                async_answer_0(callid, ELIMIT);
                                 break;
                         }
@@ -130 +138 @@
         }
 
-        // FIXME: destroy created logs
+        unregister_logs(&registered_logs);
 }