kala13x / slog Goto Github PK

Hello kala13x, I checked my program for memory-leaks using "Valgrind". We all know that Valgrin shouts at almost everything, even if theres no problem. However. Whilst checking I got the following output:

==24231== HEAP SUMMARY:
==24231==     in use at exit: 140 bytes in 2 blocks
==24231==   total heap usage: 74 allocs, 72 frees, 22,956 bytes allocated
==24231==
==24231== 20 bytes in 1 blocks are still reachable in loss record 1 of 2
==24231==    at 0x4C28BED: malloc (vg_replace_malloc.c:263)
==24231==    by 0x4EAEAB1: strdup (strdup.c:43)
==24231==    by 0x402133: init_slog (slog.c:211)
==24231==    by 0x401349: pipe_init (pipe.c:62)
==24231==    by 0x401230: main (main.c:84)
==24231==
==24231== 120 bytes in 1 blocks are definitely lost in loss record 2 of 2
==24231==    at 0x4C28BED: malloc (vg_replace_malloc.c:263)
==24231==    by 0x4E97108: getdelim (iogetdelim.c:68)
==24231==    by 0x401E4A: parse_config (slog.c:107)
==24231==    by 0x402157: init_slog (slog.c:216)
==24231==    by 0x401349: pipe_init (pipe.c:62)
==24231==    by 0x401230: main (main.c:84)
==24231==
==24231== LEAK SUMMARY:
==24231==    definitely lost: 120 bytes in 1 blocks
==24231==    indirectly lost: 0 bytes in 0 blocks
==24231==      possibly lost: 0 bytes in 0 blocks
==24231==    still reachable: 20 bytes in 1 blocks
==24231==         suppressed: 0 bytes in 0 blocks
==24231==

As you can see there are two blocks still reachable at exit. One is 20 bytes and the other 120 bytes.
So I decided to add free() after line 204 @slog.c and now it looks like:

fclose(file);
free(line);

and one of the 'loss records' in Valgrin is gone:

==32333== HEAP SUMMARY:
==32333==     in use at exit: 20 bytes in 1 blocks
==32333==   total heap usage: 68 allocs, 67 frees, 21,207 bytes allocated
==32333==
==32333== 20 bytes in 1 blocks are still reachable in loss record 1 of 1
==32333==    at 0x4C28BED: malloc (vg_replace_malloc.c:263)
==32333==    by 0x4EAEAB1: strdup (strdup.c:43)
==32333==    by 0x40213F: init_slog (slog.c:211)
==32333==    by 0x401349: pipe_init (pipe.c:62)
==32333==    by 0x401230: main (main.c:84)
==32333==
==32333== LEAK SUMMARY:
==32333==    definitely lost: 0 bytes in 0 blocks
==32333==    indirectly lost: 0 bytes in 0 blocks
==32333==      possibly lost: 0 bytes in 0 blocks
==32333==    still reachable: 20 bytes in 1 blocks
==32333==         suppressed: 0 bytes in 0 blocks

So my question is: Is that just another 'false-positive' of Valgrin or does it make sense to have a free() at that place?

Thank you very much, regards Steven.

Specs: Debian 7.8 (Wheezy) - Compiler: gcc

Hello!
I like this slog lib.
I had to modify the slog.c to able to compile it with MSYS64 (on Win11 64bits).

• Replcaced macros __FUNCTION__ by __func__ to meet the C99 standard.
• There is no syscall.h in MSYS64, so I modified the next lines
  from these:

  #if !defined(__APPLE__) && !defined(DARWIN) && !defined(WIN32)
  #include <syscall.h>
  #endif
  

  to these:

  #if !defined(__APPLE__) && !defined(DARWIN) && !defined(WIN32) && !defined(__MSYS__)
  #include <syscall.h>
  #endif
  

• There is no syscall() and __NR_gettid in MSYS64, and no 32 bits but 64 bits, so I modified from uint32_t to size_t the next lines
  from these:

  static uint32_t slog_get_tid()
  {
  #if defined(__APPLE__) || defined(DARWIN) || defined(WIN32)
      return (uint32_t)pthread_self();
  #else
      return syscall(__NR_gettid);
  #endif
  }
  

  to these:

  static size_t slog_get_tid()
  {
  #if defined(__APPLE__) || defined(DARWIN) || defined(WIN32) || defined(__MSYS__)
      return (size_t)pthread_self();
  #else
      return syscall(__NR_gettid);
  #endif
  }
  

• I modified %u to %lu in the next lines
  from these:

  static void slog_create_tid(char *pOut, int nSize, uint8_t nTraceTid)
  {
      if (!nTraceTid) pOut[0] = SLOG_NUL;
      else snprintf(pOut, nSize, "(%u) ", slog_get_tid());
  }
  

  to these:

  static void slog_create_tid(char *pOut, int nSize, uint8_t nTraceTid)
  {
      if (!nTraceTid) pOut[0] = SLOG_NUL;
      else snprintf(pOut, nSize, "(%lu) ", slog_get_tid());
  }
  

Now, with these modifications I am able to compile the slog library without any warnings and errors with MSYS64 (on Win11 64bits).

Thanks.

Would it be possible for you to tag the 1.5 release so that it's easy to clone a shallow copy (i.e., git clone https://github.com/kala13x/slog --branch 1.5 --depth 1)?

Thank you!

Currently in the README file it says: "*LOGFILELEVEL is passed as fourth argument in slog_init()."

But that does not seem quite right, because the fourth argument is whether it should be thread safe or not.

Thanks for your contribution @kala13x! This is one of the simpliest, yet easy to use logging-library.
This lib will be a part of my new project. Thumbs up !

When initializing slog after I try to log once it fails with segmentation fault.
Here is the code below:

slog_init("logfile", 1, 0);
slog_config_t slg_cfg;
slg_cfg.eColorFormat = SLOG_COLORING_FULL;
slg_cfg.eDateControl = SLOG_TIME_ONLY;
strcpy(slg_cfg.sFileName, "logfile");
strcpy(slg_cfg.sFilePath, "../logs/");

slg_cfg.nTraceTid = 1;
slg_cfg.nToScreen = 0;
slg_cfg.nToFile = 1;
slg_cfg.nUseHeap = 0;
slg_cfg.nFlush = 0;
slg_cfg.nFlags = 1;
slog_config_set(&slg_cfg);

slog_trace("some.");

NOTE: I checked and the directory exists
I found out that what causes it to crash is this: slg_cfg.nFlags = 1;
If I remove that line it runs but doesn't output anything to the file