ceph/src/pmdk/src/libpmemobj/stats.c

   1 // SPDX-License-Identifier: BSD-3-Clause
   2 /* Copyright 2017-2019, Intel Corporation */
   3
   4 /*
   5  * stats.c -- implementation of statistics
   6  */
   7
   8 #include "obj.h"
   9 #include "stats.h"
  10
  11 STATS_CTL_HANDLER(persistent, curr_allocated, heap_curr_allocated);
  12
  13 STATS_CTL_HANDLER(transient, run_allocated, heap_run_allocated);
  14 STATS_CTL_HANDLER(transient, run_active, heap_run_active);
  15
  16 static const struct ctl_node CTL_NODE(heap)[] = {
  17         STATS_CTL_LEAF(persistent, curr_allocated),
  18         STATS_CTL_LEAF(transient, run_allocated),
  19         STATS_CTL_LEAF(transient, run_active),
  20
  21         CTL_NODE_END
  22 };
  23
  24 /*
  25  * CTL_READ_HANDLER(enabled) -- returns whether or not statistics are enabled
  26  */
  27 static int
  28 CTL_READ_HANDLER(enabled)(void *ctx,
  29         enum ctl_query_source source, void *arg,
  30         struct ctl_indexes *indexes)
  31 {
  32         PMEMobjpool *pop = ctx;
  33
  34         enum pobj_stats_enabled *arg_out = arg;
  35
  36         *arg_out = pop->stats->enabled;
  37
  38         return 0;
  39 }
  40
  41 /*
  42  * stats_enabled_parser -- parses the stats enabled type
  43  */
  44 static int
  45 stats_enabled_parser(const void *arg, void *dest, size_t dest_size)
  46 {
  47         const char *vstr = arg;
  48         enum pobj_stats_enabled *enabled = dest;
  49         ASSERTeq(dest_size, sizeof(enum pobj_stats_enabled));
  50
  51         int bool_out;
  52         if (ctl_arg_boolean(arg, &bool_out, sizeof(bool_out)) == 0) {
  53                 *enabled = bool_out ?
  54                         POBJ_STATS_ENABLED_BOTH : POBJ_STATS_DISABLED;
  55                 return 0;
  56         }
  57
  58         if (strcmp(vstr, "disabled") == 0) {
  59                 *enabled = POBJ_STATS_DISABLED;
  60         } else if (strcmp(vstr, "both") == 0) {
  61                 *enabled = POBJ_STATS_ENABLED_BOTH;
  62         } else if (strcmp(vstr, "persistent") == 0) {
  63                 *enabled = POBJ_STATS_ENABLED_PERSISTENT;
  64         } else if (strcmp(vstr, "transient") == 0) {
  65                 *enabled = POBJ_STATS_ENABLED_TRANSIENT;
  66         } else {
  67                 ERR("invalid enable type");
  68                 errno = EINVAL;
  69                 return -1;
  70         }
  71
  72         return 0;
  73 }
  74
  75 /*
  76  * CTL_WRITE_HANDLER(enabled) -- enables or disables statistics counting
  77  */
  78 static int
  79 CTL_WRITE_HANDLER(enabled)(void *ctx,
  80         enum ctl_query_source source, void *arg,
  81         struct ctl_indexes *indexes)
  82 {
  83         PMEMobjpool *pop = ctx;
  84
  85         pop->stats->enabled = *(enum pobj_stats_enabled *)arg;
  86
  87         return 0;
  88 }
  89
  90 static const struct ctl_argument CTL_ARG(enabled) = {
  91         .dest_size = sizeof(enum pobj_stats_enabled),
  92         .parsers = {
  93                 CTL_ARG_PARSER(sizeof(enum pobj_stats_enabled),
  94                         stats_enabled_parser),
  95                 CTL_ARG_PARSER_END
  96         }
  97 };
  98
  99 static const struct ctl_node CTL_NODE(stats)[] = {
 100         CTL_CHILD(heap),
 101         CTL_LEAF_RW(enabled),
 102
 103         CTL_NODE_END
 104 };
 105
 106 /*
 107  * stats_new -- allocates and initializes statistics instance
 108  */
 109 struct stats *
 110 stats_new(PMEMobjpool *pop)
 111 {
 112         struct stats *s = Malloc(sizeof(*s));
 113         if (s == NULL) {
 114                 ERR("!Malloc");
 115                 return NULL;
 116         }
 117
 118         s->enabled = POBJ_STATS_ENABLED_TRANSIENT;
 119         s->persistent = &pop->stats_persistent;
 120         VALGRIND_ADD_TO_GLOBAL_TX_IGNORE(s->persistent, sizeof(*s->persistent));
 121         s->transient = Zalloc(sizeof(struct stats_transient));
 122         if (s->transient == NULL)
 123                 goto error_transient_alloc;
 124
 125         return s;
 126
 127 error_transient_alloc:
 128         Free(s);
 129         return NULL;
 130 }
 131
 132 /*
 133  * stats_delete -- deletes statistics instance
 134  */
 135 void
 136 stats_delete(PMEMobjpool *pop, struct stats *s)
 137 {
 138         pmemops_persist(&pop->p_ops, s->persistent,
 139         sizeof(struct stats_persistent));
 140         Free(s->transient);
 141         Free(s);
 142 }
 143
 144 /*
 145  * stats_ctl_register -- registers ctl nodes for statistics
 146  */
 147 void
 148 stats_ctl_register(PMEMobjpool *pop)
 149 {
 150         CTL_REGISTER_MODULE(pop->ctl, stats);
 151 }