1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
// SPDX-License-Identifier: GPL-2.0
#include <stdint.h>
#include <string.h>
#include <time.h>
#include <sched.h>
#include <stdbool.h>
#include <stdlib.h>
#include <linux/container_of.h>
/*
* '18446744073709551615\0'
*/
#define BUFF_U64_STR_SIZE 24
#define MAX_PATH 1024
#define MAX_NICE 20
#define MIN_NICE -19
#ifndef ARRAY_SIZE
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))
#endif
/* Calculate string length at compile time (excluding null terminator) */
#define STRING_LENGTH(s) (ARRAY_SIZE(s) - sizeof(*(s)))
/* Compare string with static string, length determined at compile time */
#define strncmp_static(s1, s2) strncmp(s1, s2, ARRAY_SIZE(s2))
/**
* str_has_prefix - Test if a string has a given prefix
* @str: The string to test
* @prefix: The string to see if @str starts with
*
* Returns: true if @str starts with @prefix, false otherwise
*/
static inline bool str_has_prefix(const char *str, const char *prefix)
{
return strncmp(str, prefix, strlen(prefix)) == 0;
}
extern bool config_debug;
extern int nr_cpus;
void debug_msg(const char *fmt, ...);
void err_msg(const char *fmt, ...);
void fatal(const char *fmt, ...);
long parse_seconds_duration(char *val);
void get_duration(time_t start_time, char *output, int output_size);
int cpu_list_iterate(const char *cpu_list, int (*callback)(int, void *), void *data);
int get_max_cpu_from_list(const char *cpu_list);
int get_possible_cpus(void);
long long get_llong_from_str(char *start);
static inline void
update_min(unsigned long long *a, unsigned long long *b)
{
if (*a > *b)
*a = *b;
}
static inline void
update_max(unsigned long long *a, unsigned long long *b)
{
if (*a < *b)
*a = *b;
}
static inline void
update_sum(unsigned long long *a, unsigned long long *b)
{
*a += *b;
}
#ifndef SCHED_ATTR_SIZE_VER0
struct sched_attr {
uint32_t size;
uint32_t sched_policy;
uint64_t sched_flags;
int32_t sched_nice;
uint32_t sched_priority;
uint64_t sched_runtime;
uint64_t sched_deadline;
uint64_t sched_period;
};
#endif /* SCHED_ATTR_SIZE_VER0 */
enum stack_format {
STACK_FORMAT_TRUNCATE,
STACK_FORMAT_SKIP,
STACK_FORMAT_FULL
};
int parse_prio(char *arg, struct sched_attr *sched_param);
int parse_cpu_set(char *cpu_list, cpu_set_t *set);
int parse_stack_format(char *arg);
int __set_sched_attr(int pid, struct sched_attr *attr);
int set_comm_sched_attr(const char *comm_prefix, struct sched_attr *attr);
int set_comm_cgroup(const char *comm_prefix, const char *cgroup);
int set_pid_cgroup(pid_t pid, const char *cgroup);
int set_cpu_dma_latency(int32_t latency);
void *calloc_fatal(size_t n, size_t size);
void *reallocarray_fatal(void *p, size_t n, size_t size);
char *strdup_fatal(const char *s);
#ifdef HAVE_LIBCPUPOWER_SUPPORT
int save_cpu_idle_disable_state(unsigned int cpu);
int restore_cpu_idle_disable_state(unsigned int cpu);
void free_cpu_idle_disable_states(void);
int set_deepest_cpu_idle_state(unsigned int cpu, unsigned int state);
static inline int have_libcpupower_support(void) { return 1; }
#else
static inline int save_cpu_idle_disable_state(unsigned int cpu) { return -1; }
static inline int restore_cpu_idle_disable_state(unsigned int cpu) { return -1; }
static inline void free_cpu_idle_disable_states(void) { }
static inline int set_deepest_cpu_idle_state(unsigned int cpu, unsigned int state) { return -1; }
static inline int have_libcpupower_support(void) { return 0; }
#endif /* HAVE_LIBCPUPOWER_SUPPORT */
int auto_house_keeping(cpu_set_t *monitored_cpus);
__attribute__((__warn_unused_result__)) int strtoi(const char *s, int *res);
#define ns_to_usf(x) (((double)x/1000))
#define ns_to_per(total, part) ((part * 100) / (double)total)
enum result {
PASSED = EXIT_SUCCESS,
ERROR = EXIT_FAILURE,
FAILED, /* test hit the stop tracing condition */
};
|
