src/report-generator.h

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef __REPORT_GENERATOR_H_
  18 #define __REPORT_GENERATOR_H_
  19
  20 #include "report.h"
  21
  22 /** Generator for system-wide reports */
  23 typedef struct report_generator_system report_generator_system_t;
  24
  25 /** Generator for per process report */
  26 typedef struct report_generator_process report_generator_process_t;
  27
  28 /** Generator for app report */
  29 typedef struct report_generator_app report_generator_app_t;
  30
  31 /**
  32  * @brief Creates new instance of report_generator_system_t
  33  * @return new report_generator_system_t object, or NULL on error
  34  *
  35  * @remark return value should be released with
  36  * @report_generator_free_system_generator
  37  */
  38 report_generator_system_t *report_generator_new_system_report_generator();
  39
  40 /**
  41  * @brief Release report_generator_system_t created with
  42  * @report_generator_new_system_report_generator
  43  */
  44 void report_generator_free_system_generator(report_generator_system_t *generator);
  45
  46 /**
  47  * @brief Creates new instance of report_generator_process_t
  48  *
  49  * @param[in] process PID
  50  * @return new report_generator_system_t object, or NULL on error
  51  *
  52  * @remark return value should be released with
  53  * @report_generator_free_process_generator
  54  */
  55 report_generator_process_t *report_generator_new_process_report_generator(int pid);
  56
  57 /**
  58  * @brief Release report_generator_process_t created with
  59  * @report_generator_new_process_report_generator
  60  */
  61 void report_generator_free_process_generator(report_generator_process_t *generator);
  62
  63 /**
  64  * @brief Creates new instance of report_generator_app_t
  65  *
  66  * @param[in] Apps id.
  67  * @return New report_generator_app_t object, or NULL on error
  68  *
  69  * @remark return value should be released with
  70  * @report_generator_free_app_generator
  71  */
  72 report_generator_app_t *report_generator_new_app_report_generator(const char *app_id);
  73
  74 /**
  75  * @brief Release report_generator_app_t created with
  76  * @report_generator_new_app_report_generator
  77  */
  78 void report_generator_free_app_generator(report_generator_app_t *generator);
  79
  80 /**
  81  * @brief Fills system_cpu_usage_report.
  82  *
  83  * When interval > 0 the function will block for interval seconds and return report with
  84  * system cpu usage calculated as average during interval period.
  85  * When interval == 0 the function will not block and return report with cpu
  86  * system usage calculated as average between current time and last call to
  87  * report_generator_generate_system_cpu_usage_report for generator
  88  *
  89  * @param[in] generator system generator
  90  * @param[in] interval in seconds, Should be >= 0
  91  * @param[out] report
  92  * @return 0 on success, other value on failure
  93  */
  94 int report_generator_generate_system_cpu_usage_report(
  95                 report_generator_system_t *generator,
  96                 int interval,
  97                 struct system_cpu_usage_report *report);
  98
  99 /**
 100  * @brief Fills system_percpu_usage_report.
 101  *
 102  * When interval > 0 the function will block for interval seconds and return report with
 103  * system cpus usage calculated as average during interval period.
 104  * When interval == 0 the function will not block and return report with system cpus
 105  * usage calculated as average between current time and last call to
 106  * report_generator_generate_system_percpu_usage_report for generator
 107  *
 108  * @param[in] generator system generator
 109  * @param[in] interval in seconds, Should be >= 0
 110  * @param[out] report
 111  * @return 0 on success, other value on failure
 112  *
 113  * @remark report should be released with @free
 114  */
 115 int report_generator_generate_percpu_usage_report(
 116                 report_generator_system_t *generator,
 117                 int interval,
 118                 struct system_percpu_usage_report **report);
 119
 120 /**
 121  * @brief Fills system_memory_usage_report.
 122  *
 123  * @param[in] generator system generator
 124  * @param[out] report
 125  * @return 0 on success, other value on failure
 126  */
 127 int report_generator_generate_system_memory_usage_report(
 128                 report_generator_system_t *generator,
 129                 struct system_memory_usage_report *report);
 130
 131 /**
 132  * @brief Fills process_cpu_usage_report.
 133  *
 134  * When interval > 0 the function will block for interval seconds and return report with
 135  * process cpu usage calculated as average during interval period.
 136  * When interval == 0 the function will not block and return report with process
 137  * cpu usage calculated as average between current time and last call to
 138  * report_generator_generate_process_cpu_usage_report for generator
 139  *
 140  * @param[in] generator process generator
 141  * @param[in] interval in seconds, Should be >= 0
 142  * @param[out] report
 143  * @return 0 on success, other value on failure
 144  */
 145 int report_generator_generate_process_cpu_usage_report(
 146                 report_generator_process_t *generator,
 147                 int interval,
 148                 struct process_cpu_usage_report *report);
 149
 150 /**
 151  * @brief Fills process_memory_usage_report.
 152  *
 153  * @param[in] generator process generator
 154  * @param[out] report
 155  * @return 0 on success, other value on failure
 156  */
 157 int report_generator_generate_proccess_memory_usage_report(
 158                 report_generator_process_t *generator,
 159                 struct process_memory_usage_report *report);
 160
 161 /**
 162  * @brief Fills apps_cpu_usage_report.
 163  *
 164  * When interval > 0 the function will block for interval seconds and return report with
 165  * apps cpu usage calculated as average during interval period.
 166  * When interval == 0 the function will not block and return report with apps
 167  * cpu usage calculated as average between current time and last call to
 168  * report_generator_generate_process_cpu_usage_report for generator
 169  *
 170  * @param[in] generator apps generator
 171  * @param[in] interval in seconds, Should be >= 0
 172  * @param[out] report
 173  * @return 0 on success, other value on failure
 174  * @remarks Returned value should be freed.
 175  */
 176 int report_generator_generate_app_cpu_usage_report(
 177                 report_generator_app_t *generator,
 178                 int interval,
 179                 struct app_cpu_usage_report *report);
 180
 181 /**
 182  * @brief Fills process_memory_usage_report.
 183  *
 184  * @param[in] generator apps generator
 185  * @param[out] report
 186  * @return 0 on success, other value on failure
 187  */
 188 int report_generator_generate_app_memory_usage_report(
 189                 report_generator_app_t *generator,
 190                 struct app_memory_usage_report *report);
 191
 192 /**
 193  * @brief Fills system_load_average_report
 194  *
 195  * @param[out] report
 196  * @return 0 on success, other value on failure
 197  */
 198 int report_generator_generate_load_average_report(
 199    struct system_load_average_report *report);
 200
 201 #endif