From 5fc9f555176bbbc354d651e6e31f618aea0b2b7d Mon Sep 17 00:00:00 2001
From: Hans de Goede <hdegoede@redhat.com>
Date: Tue, 17 Jul 2018 09:46:12 +0200
Subject: [PATCH] logger: Add a separator between different boot logs

Since we concatenate boot logs one after the other in /var/log/boot.log
it is hard to tell where the logs from one boot end the next boot starts.

This commit makes plymouth write out a separator including a time + date
of the date, when the log file gets opened to add new boot messages to it.

Note ply_logger_open_file() is only called from ply_terminal_session_open_log()
which in turn is only used for /var/log/boot.log, so this only effects
/var/log/boot.log.

Closes #29

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
---
 src/libply/ply-logger.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/libply/ply-logger.c b/src/libply/ply-logger.c
index 1b56ea8..3dbc3ca 100644
--- a/src/libply/ply-logger.c
+++ b/src/libply/ply-logger.c
@@ -7,60 +7,61 @@
  * the Free Software Foundation; either version 2, or (at your option)
  * any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  * 02111-1307, USA.
  *
  * Written by: Ray Strode <rstrode@redhat.com>
  */
 #include "config.h"
 #include "ply-logger.h"
 
 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/fcntl.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <time.h>
 #include <unistd.h>
 
 #include "ply-utils.h"
 #include "ply-list.h"
 
 #ifndef PLY_LOGGER_OPEN_FLAGS
 #define PLY_LOGGER_OPEN_FLAGS (O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW | O_CLOEXEC)
 #endif
 
 #ifndef PLY_LOGGER_MAX_INJECTION_SIZE
 #define PLY_LOGGER_MAX_INJECTION_SIZE 4096
 #endif
 
 #ifndef PLY_LOGGER_MAX_BUFFER_CAPACITY
 #define PLY_LOGGER_MAX_BUFFER_CAPACITY (8 * 4096)
 #endif
 
 typedef struct
 {
         ply_logger_filter_handler_t handler;
         void                       *user_data;
 } ply_logger_filter_t;
 
 struct _ply_logger
 {
         int                       output_fd;
         char                     *filename;
 
         char                     *buffer;
         size_t                    buffer_size;
@@ -285,77 +286,89 @@ ply_logger_free_filters (ply_logger_t *logger)
                 free (filter);
                 node = next_node;
         }
 
         ply_list_free (logger->filters);
 }
 
 void
 ply_logger_free (ply_logger_t *logger)
 {
         if (logger == NULL)
                 return;
 
         if (logger->output_fd >= 0) {
                 if (ply_logger_is_logging (logger))
                         ply_logger_flush (logger);
                 close (logger->output_fd);
         }
 
         ply_logger_free_filters (logger);
 
         free (logger->filename);
         free (logger->buffer);
         free (logger);
 }
 
 bool
 ply_logger_open_file (ply_logger_t *logger,
                       const char   *filename)
 {
+        char header[80];
+        struct tm* tm;
+        time_t t;
         int fd;
         mode_t mode;
 
         assert (logger != NULL);
         assert (filename != NULL);
 
         fd = open (filename, PLY_LOGGER_OPEN_FLAGS, 0600);
 
         if (fd < 0)
                 return false;
 
         ply_logger_set_output_fd (logger, fd);
 
         free (logger->filename);
 
         logger->filename = strdup (filename);
 
+        time (&t);
+        tm = localtime (&t);
+        if (tm) {
+                /* This uses uname -v date format */
+                strftime (header, sizeof(header),
+                         "------------ %a %b %d %T %Z %Y ------------\n", tm);
+                ply_logger_write (logger, header, strlen(header), true);
+        }
+
         return true;
 }
 
 void
 ply_logger_close_file (ply_logger_t *logger)
 {
         assert (logger != NULL);
 
         if (logger->output_fd < 0)
                 return;
 
         close (logger->output_fd);
         ply_logger_set_output_fd (logger, -1);
 }
 
 void
 ply_logger_set_output_fd (ply_logger_t *logger,
                           int           fd)
 {
         assert (logger != NULL);
 
         logger->output_fd = fd;
 }
 
 int
 ply_logger_get_output_fd (ply_logger_t *logger)
 {
         assert (logger != NULL);
 
         return logger->output_fd;
-- 
2.18.1