libply: Add support for syslog

Sometimes plymouth is used along-side other programs. Those
programs may use syslog for logging, and so it would be useful
if plymouth had the ability to use syslog, too. Then message
ordering would be more coherent.

This commit adds such support by adding plymouth.debug=syslog
to the kernel command line.

src/libply/ply-logger.c

@@ -73,6 +73,9 @@ struct _ply_logger
 
         uint32_t                  is_enabled : 1;
         uint32_t                  tracing_is_enabled : 1;
+        uint32_t                  syslog_is_enabled : 1;
+        uint32_t                  is_error_default : 1;
+        uint32_t                  is_default : 1;
 };
 
 static bool ply_text_is_loggable (const char *string,
@@ -117,6 +120,13 @@ ply_logger_write_exception (ply_logger_t *logger,
 
         assert (message != NULL);
 
+        if (logger->syslog_is_enabled) {
+                syslog (LOG_WARNING,
+                        "%.*s",
+                        message,
+                        number_of_bytes);
+        }
+
         ply_logger_write (logger, message, number_of_bytes, false);
         free (message);
 }
@@ -155,6 +165,23 @@ ply_logger_flush_buffer (ply_logger_t *logger)
         if (logger->buffer_size == 0)
                 return true;
 
+        if (logger->syslog_is_enabled) {
+                int log_priority;
+
+                if (logger->tracing_is_enabled) {
+                        log_priority = LOG_DEBUG;
+                } else if (logger->is_default) {
+                        log_priority = LOG_INFO;
+                } else if (logger->is_error_default) {
+                        log_priority = LOG_WARNING;
+                }
+
+                syslog (log_priority,
+                        "%.*s",
+                        logger->buffer_size,
+                        logger->buffer);
+        }
+
         if (!ply_logger_write (logger, logger->buffer, logger->buffer_size, true))
                 return false;
 
@@ -252,6 +279,7 @@ ply_logger_get_default (void)
         if (logger == NULL) {
                 logger = ply_logger_new ();
                 ply_logger_set_output_fd (logger, STDOUT_FILENO);
+                logger->is_default = true;
         }
 
         return logger;
@@ -267,6 +295,7 @@ ply_logger_get_error_default (void)
                 ply_logger_set_output_fd (logger, STDERR_FILENO);
                 ply_logger_set_flush_policy (logger,
                                              PLY_LOGGER_FLUSH_POLICY_EVERY_TIME);
+                logger->is_error_default = true;
         }
 
         return logger;
@@ -304,6 +333,10 @@ ply_logger_free (ply_logger_t *logger)
                 close (logger->output_fd);
         }
 
+        if (logger->syslog_is_enabled) {
+                ply_logger_close_syslog (logger);
+        }
+
         ply_logger_free_filters (logger);
 
         free (logger->filename);
@@ -358,6 +391,18 @@ ply_logger_close_file (ply_logger_t *logger)
         ply_logger_set_output_fd (logger, -1);
 }
 
+void
+ply_logger_open_syslog (ply_logger_t *logger)
+{
+        openlog (NULL, 0, LOG_DAEMON);
+}
+
+void
+ply_logger_close_syslog (ply_logger_t *logger)
+{
+        closelog ();
+}
+
 void
 ply_logger_set_output_fd (ply_logger_t *logger,
                           int           fd)

src/libply/ply-logger.h

@@ -49,6 +49,8 @@ void ply_logger_free (ply_logger_t *logger);
 bool ply_logger_open_file (ply_logger_t *logger,
                            const char   *filename);
 void ply_logger_close_file (ply_logger_t *logger);
+bool ply_logger_open_syslog (ply_logger_t *logger);
+void ply_logger_close_syslog (ply_logger_t *logger);
 void ply_logger_set_output_fd (ply_logger_t *logger,
                                int           fd);
 int ply_logger_get_output_fd (ply_logger_t *logger);

src/main.c

@@ -1857,6 +1857,8 @@ static void
 check_verbosity (state_t *state)
 {
         char *stream;
+        char *syslog;
+        bool found_output_target = false;
 
         ply_trace ("checking if tracing should be enabled");
 
@@ -1906,7 +1908,18 @@ check_verbosity (state_t *state)
 
                         free (file);
                 }
-        } else {
+
+                found_output_target = true;
+        }
+
+        syslog = ply_kernel_command_line_get_key_value ("plymouth.debug=syslog");
+
+        if (syslog != NULL) {
+                ply_logger_open_syslog (ply_logger_get_error_default ());
+                found_output_target = true;
+        }
+
+        if (!found_output_target) {
                 ply_trace ("tracing shouldn't be enabled!");
         }