LCOV - code coverage report
Current view: top level - lib/log - log_flags.c (source / functions) Hit Total Coverage
Test: ut_cov_unit.info Lines: 36 47 76.6 %
Date: 2024-07-11 20:25:41 Functions: 7 9 77.8 %

          Line data    Source code
       1             : /*   SPDX-License-Identifier: BSD-3-Clause
       2             :  *   Copyright (C) 2017 Intel Corporation.
       3             :  *   All rights reserved.
       4             :  */
       5             : 
       6             : #include "spdk/stdinc.h"
       7             : 
       8             : #include "spdk/log.h"
       9             : 
      10             : static TAILQ_HEAD(, spdk_log_flag) g_log_flags = TAILQ_HEAD_INITIALIZER(g_log_flags);
      11             : 
      12             : static struct spdk_log_flag *
      13         299 : get_log_flag(const char *name)
      14             : {
      15             :         struct spdk_log_flag *flag;
      16             : 
      17         709 :         TAILQ_FOREACH(flag, &g_log_flags, tailq) {
      18         460 :                 if (strcasecmp(name, flag->name) == 0) {
      19          50 :                         return flag;
      20             :                 }
      21             :         }
      22             : 
      23         249 :         return NULL;
      24             : }
      25             : 
      26             : void
      27         249 : spdk_log_register_flag(const char *name, struct spdk_log_flag *flag)
      28             : {
      29             :         struct spdk_log_flag *iter;
      30             : 
      31         249 :         if (name == NULL || flag == NULL) {
      32           0 :                 SPDK_ERRLOG("missing spdk_log_flag parameters\n");
      33           0 :                 assert(false);
      34             :                 return;
      35             :         }
      36             : 
      37         249 :         if (get_log_flag(name)) {
      38           0 :                 SPDK_ERRLOG("duplicate spdk_log_flag '%s'\n", name);
      39           0 :                 assert(false);
      40             :                 return;
      41             :         }
      42             : 
      43         441 :         TAILQ_FOREACH(iter, &g_log_flags, tailq) {
      44         284 :                 if (strcasecmp(iter->name, flag->name) > 0) {
      45          92 :                         TAILQ_INSERT_BEFORE(iter, flag, tailq);
      46          92 :                         return;
      47             :                 }
      48             :         }
      49             : 
      50         157 :         TAILQ_INSERT_TAIL(&g_log_flags, flag, tailq);
      51             : }
      52             : 
      53             : bool
      54          50 : spdk_log_get_flag(const char *name)
      55             : {
      56          50 :         struct spdk_log_flag *flag = get_log_flag(name);
      57             : 
      58          50 :         if (flag && flag->enabled) {
      59           1 :                 return true;
      60             :         }
      61             : 
      62          49 :         return false;
      63             : }
      64             : 
      65             : static int
      66           3 : log_set_flag(const char *name, bool value)
      67             : {
      68             :         struct spdk_log_flag *flag;
      69           3 :         int rc = -EINVAL;
      70             : 
      71           3 :         if (strcasecmp(name, "all") == 0) {
      72           0 :                 TAILQ_FOREACH(flag, &g_log_flags, tailq) {
      73           0 :                         flag->enabled = value;
      74             :                 }
      75           0 :                 return 0;
      76             :         }
      77             : 
      78           6 :         TAILQ_FOREACH(flag, &g_log_flags, tailq) {
      79           3 :                 if (fnmatch(name, flag->name, FNM_CASEFOLD) == 0) {
      80           3 :                         flag->enabled = value;
      81           3 :                         rc = 0;
      82             :                 }
      83             :         }
      84             : 
      85           3 :         return rc;
      86             : }
      87             : 
      88             : int
      89           2 : spdk_log_set_flag(const char *name)
      90             : {
      91           2 :         return log_set_flag(name, true);
      92             : }
      93             : 
      94             : int
      95           1 : spdk_log_clear_flag(const char *name)
      96             : {
      97           1 :         return log_set_flag(name, false);
      98             : }
      99             : 
     100             : struct spdk_log_flag *
     101           0 : spdk_log_get_first_flag(void)
     102             : {
     103           0 :         return TAILQ_FIRST(&g_log_flags);
     104             : }
     105             : 
     106             : struct spdk_log_flag *
     107           0 : spdk_log_get_next_flag(struct spdk_log_flag *flag)
     108             : {
     109           0 :         return TAILQ_NEXT(flag, tailq);
     110             : }
     111             : 
     112             : void
     113           3 : spdk_log_usage(FILE *f, const char *log_arg)
     114             : {
     115             :         struct spdk_log_flag *flag;
     116           3 :         fprintf(f, " %s, --logflag <flag>    enable log flag (all", log_arg);
     117             : 
     118          18 :         TAILQ_FOREACH(flag, &g_log_flags, tailq) {
     119          15 :                 fprintf(f, ", %s", flag->name);
     120             :         }
     121             : 
     122           3 :         fprintf(f, ")\n");
     123           3 : }

Generated by: LCOV version 1.15