//------------------------------------------------------------------------------
// Function Name : dbg_msg_co()
// Description :
//------------------------------------------------------------------------------
void dbg_msg_co(int color, const char *fmt, ...)
{
char _buf[256] = {0,};
va_list args;
int len;
switch (color) {
case CO_RED:
case CO_GREEN:
case CO_YELLOW:
case CO_BLUE:
case CO_MAGENTA:
case CO_CYAN:
case CO_WHITE:
sprintf(_buf, "%s[%8u] ", col_str[color], log_uptime());
break;
case CO_DEF:
default:
sprintf(_buf, "%s[%8u] ", col_str[CO_DEF], log_uptime());
break;
}
len = strlen(_buf);
va_start(args, fmt);
vsnprintf(_buf + len, 256 - len - 1, fmt, args);
va_end(args);
fprintf(stdout, "%s%s\n", _buf, col_str[CO_DEF]);
}
//------------------------------------------------------------------------------
// Function Name : dbg_msg()
// Description :
//------------------------------------------------------------------------------
void dbg_msg(const char *fmt, ...)
{
char _buf[256] = {0,};
va_list args;
int len;
sprintf(_buf, "%s[%8u] ", col_str[CO_DEF], log_uptime());
len = strlen(_buf);
va_start(args, fmt);
vsnprintf(_buf + len, 256 - len - 1, fmt, args);
va_end(args);
}
int main(int argc, char *argv[])
{
struct sigaction sig;
struct ps_struct *ps;
char output_file[PATH_MAX];
char datestr[200];
time_t t;
FILE *f;
memset(&t, 0, sizeof(time_t));
rlim.rlim_cur = 4096;
rlim.rlim_max = 4096;
(void) setrlimit(RLIMIT_NOFILE, &rlim);
f = fopen("/etc/bootchartd.conf", "r");
if (f) {
char buf[256];
char *key;
char *val;
while (fgets(buf, 80, f) != NULL) {
char *c;
c = strchr(buf, '\n');
if (c) *c = 0; /* remove trailing \n */
if (buf[0] == '#')
continue; /* comment line */
key = strtok(buf, "=");
if (!key)
continue;
val = strtok(NULL, "=");
if (!val)
continue;
// todo: filter leading/trailing whitespace
if (!strcmp(key, "samples"))
len = atoi(val);
if (!strcmp(key, "freq"))
hz = atof(val);
if (!strcmp(key, "rel"))
relative = atoi(val);
if (!strcmp(key, "filter"))
filter = atoi(val);
if (!strcmp(key, "pss"))
pss = atoi(val);
if (!strcmp(key, "output"))
strncpy(output_path, val, PATH_MAX - 1);
if (!strcmp(key, "init"))
strncpy(init_path, val, PATH_MAX - 1);
if (!strcmp(key, "scale_x"))
scale_x = atof(val);
if (!strcmp(key, "scale_y"))
scale_y = atof(val);
if (!strcmp(key, "entropy"))
entropy = atoi(val);
}
fclose(f);
}
while (1) {
static struct option opts[] = {
{"rel", 0, NULL, 'r'},
{"freq", 1, NULL, 'f'},
{"samples", 1, NULL, 'n'},
{"pss", 0, NULL, 'p'},
{"output", 1, NULL, 'o'},
{"init", 1, NULL, 'i'},
{"filter", 0, NULL, 'F'},
{"help", 0, NULL, 'h'},
{"scale-x", 1, NULL, 'x'},
{"scale-y", 1, NULL, 'y'},
{"entropy", 0, NULL, 'e'},
{NULL, 0, NULL, 0}
};
int index = 0, c;
c = getopt_long(argc, argv, "erpf:n:o:i:Fhx:y:", opts, &index);
if (c == -1)
break;
switch (c) {
case 'r':
relative = 1;
break;
case 'f':
hz = atof(optarg);
break;
case 'F':
filter = 0;
break;
case 'n':
len = atoi(optarg);
break;
case 'o':
strncpy(output_path, optarg, PATH_MAX - 1);
break;
case 'i':
strncpy(init_path, optarg, PATH_MAX - 1);
break;
case 'p':
pss = 1;
break;
case 'x':
scale_x = atof(optarg);
break;
case 'y':
scale_y = atof(optarg);
break;
case 'e':
entropy = 1;
break;
case 'h':
fprintf(stderr, "Usage: %s [OPTIONS]\n", argv[0]);
fprintf(stderr, " --rel, -r Record time relative to recording\n");
fprintf(stderr, " --freq, -f N Sample frequency [%f]\n", hz);
fprintf(stderr, " --samples, -n N Stop sampling at [%d] samples\n", len);
fprintf(stderr, " --scale-x, -x N Scale the graph horizontally [%f] \n", scale_x);
fprintf(stderr, " --scale-y, -y N Scale the graph vertically [%f] \n", scale_y);
fprintf(stderr, " --pss, -p Enable PSS graph (CPU intensive)\n");
fprintf(stderr, " --entropy, -e Enable the entropy_avail graph\n");
fprintf(stderr, " --output, -o [PATH] Path to output files [%s]\n", output_path);
fprintf(stderr, " --init, -i [PATH] Path to init executable [%s]\n", init_path);
fprintf(stderr, " --filter, -F Disable filtering of processes from the graph\n");
fprintf(stderr, " that are of less importance or short-lived\n");
fprintf(stderr, " --help, -h Display this message\n");
fprintf(stderr, "See the installed README and bootchartd.conf.example for more information.\n");
exit (EXIT_SUCCESS);
break;
default:
break;
}
}
if (len > MAXSAMPLES) {
fprintf(stderr, "Error: samples exceeds maximum\n");
exit(EXIT_FAILURE);
}
if (hz <= 0.0) {
fprintf(stderr, "Error: Frequency needs to be > 0\n");
exit(EXIT_FAILURE);
}
/*
* If the kernel executed us through init=/sbin/bootchartd, then
* fork:
* - parent execs executable specified via init_path[] (/sbin/init by default) as pid=1
* - child logs data
*/
if (getpid() == 1) {
if (fork()) {
/* parent */
execl(init_path, init_path, NULL);
}
}
/* start with empty ps LL */
ps_first = malloc(sizeof(struct ps_struct));
if (!ps_first) {
perror("malloc(ps_struct)");
exit(EXIT_FAILURE);
}
memset(ps_first, 0, sizeof(struct ps_struct));
/* handle TERM/INT nicely */
memset(&sig, 0, sizeof(struct sigaction));
sig.sa_handler = signal_handler;
sigaction(SIGHUP, &sig, NULL);
interval = (1.0 / hz) * 1000000000.0;
log_uptime();
/* main program loop */
while (!exiting) {
int res;
double sample_stop;
struct timespec req;
time_t newint_s;
long newint_ns;
double elapsed;
double timeleft;
sampletime[samples] = gettime_ns();
/* wait for /proc to become available, discarding samples */
if (!graph_start)
log_uptime();
else
log_sample(samples);
sample_stop = gettime_ns();
elapsed = (sample_stop - sampletime[samples]) * 1000000000.0;
timeleft = interval - elapsed;
newint_s = (time_t)(timeleft / 1000000000.0);
newint_ns = (long)(timeleft - (newint_s * 1000000000.0));
/*
* check if we have not consumed our entire timeslice. If we
* do, don't sleep and take a new sample right away.
* we'll lose all the missed samples and overrun our total
* time
*/
if ((newint_ns > 0) || (newint_s > 0)) {
req.tv_sec = newint_s;
req.tv_nsec = newint_ns;
res = nanosleep(&req, NULL);
if (res) {
if (errno == EINTR) {
/* caught signal, probably HUP! */
break;
}
perror("nanosleep()");
exit (EXIT_FAILURE);
}
} else {
overrun++;
/* calculate how many samples we lost and scrap them */
len = len + ((int)(newint_ns / interval));
}
samples++;
if (samples > len)
break;
}
/* do some cleanup, close fd's */
ps = ps_first;
while (ps->next_ps) {
ps = ps->next_ps;
if (ps->schedstat)
close(ps->schedstat);
if (ps->sched)
close(ps->sched);
if (ps->smaps)
fclose(ps->smaps);
}
closedir(proc);
t = time(NULL);
strftime(datestr, sizeof(datestr), "%Y%m%d-%H%M", localtime(&t));
snprintf(output_file, PATH_MAX, "%s/bootchart-%s.svg", output_path, datestr);
of = fopen(output_file, "w");
if (!of) {
perror("open output_file");
exit (EXIT_FAILURE);
}
svg_do();
fprintf(stderr, "bootchartd: Wrote %s\n", output_file);
fclose(of);
/* nitpic cleanups */
ps = ps_first;
while (ps->next_ps) {
struct ps_struct *old = ps;
ps = ps->next_ps;
free(old->sample);
free(old);
}
free(ps->sample);
free(ps);
/* don't complain when overrun once, happens most commonly on 1st sample */
if (overrun > 1)
fprintf(stderr, "bootchartd: Warning: sample time overrun %i times\n", overrun);
return 0;
}
int main(int argc, char *argv[]) {
_cleanup_free_ char *build = NULL;
struct sigaction sig = {
.sa_handler = signal_handler,
};
struct ps_struct *ps;
char output_file[PATH_MAX];
char datestr[200];
time_t t = 0;
int r;
struct rlimit rlim;
parse_conf();
r = parse_args(argc, argv);
if (r < 0)
return EXIT_FAILURE;
/*
* If the kernel executed us through init=/usr/lib/systemd/systemd-bootchart, then
* fork:
* - parent execs executable specified via init_path[] (/sbin/init by default) as pid=1
* - child logs data
*/
if (getpid() == 1) {
if (fork()) {
/* parent */
execl(arg_init_path, arg_init_path, NULL);
}
}
argv[0][0] = '@';
rlim.rlim_cur = 4096;
rlim.rlim_max = 4096;
(void) setrlimit(RLIMIT_NOFILE, &rlim);
/* start with empty ps LL */
ps_first = calloc(1, sizeof(struct ps_struct));
if (!ps_first) {
perror("calloc(ps_struct)");
exit(EXIT_FAILURE);
}
/* handle TERM/INT nicely */
sigaction(SIGHUP, &sig, NULL);
interval = (1.0 / arg_hz) * 1000000000.0;
log_uptime();
LIST_HEAD_INIT(struct list_sample_data, head);
/* main program loop */
for (samples = 0; !exiting && samples < arg_samples_len; samples++) {
int res;
double sample_stop;
struct timespec req;
time_t newint_s;
long newint_ns;
double elapsed;
double timeleft;
sampledata = new0(struct list_sample_data, 1);
if (sampledata == NULL) {
log_error("Failed to allocate memory for a node: %m");
return -1;
}
sampledata->sampletime = gettime_ns();
sampledata->counter = samples;
if (!of && (access(arg_output_path, R_OK|W_OK|X_OK) == 0)) {
t = time(NULL);
strftime(datestr, sizeof(datestr), "%Y%m%d-%H%M", localtime(&t));
snprintf(output_file, PATH_MAX, "%s/bootchart-%s.svg", arg_output_path, datestr);
of = fopen(output_file, "w");
}
if (sysfd < 0)
sysfd = open("/sys", O_RDONLY);
if (!build)
parse_env_file("/etc/os-release", NEWLINE,
"PRETTY_NAME", &build,
NULL);
/* wait for /proc to become available, discarding samples */
if (graph_start <= 0.0)
log_uptime();
else
log_sample(samples, &sampledata);
sample_stop = gettime_ns();
elapsed = (sample_stop - sampledata->sampletime) * 1000000000.0;
timeleft = interval - elapsed;
newint_s = (time_t)(timeleft / 1000000000.0);
newint_ns = (long)(timeleft - (newint_s * 1000000000.0));
/*
* check if we have not consumed our entire timeslice. If we
* do, don't sleep and take a new sample right away.
* we'll lose all the missed samples and overrun our total
* time
*/
if (newint_ns > 0 || newint_s > 0) {
req.tv_sec = newint_s;
req.tv_nsec = newint_ns;
res = nanosleep(&req, NULL);
if (res) {
if (errno == EINTR) {
/* caught signal, probably HUP! */
break;
}
perror("nanosleep()");
exit (EXIT_FAILURE);
}
} else {
overrun++;
/* calculate how many samples we lost and scrap them */
arg_samples_len -= (int)(newint_ns / interval);
}
LIST_PREPEND(struct list_sample_data, link, head, sampledata);
}
/* do some cleanup, close fd's */
ps = ps_first;
while (ps->next_ps) {
ps = ps->next_ps;
if (ps->schedstat)
close(ps->schedstat);
if (ps->sched)
close(ps->sched);
if (ps->smaps)
fclose(ps->smaps);
}
if (!of) {
t = time(NULL);
strftime(datestr, sizeof(datestr), "%Y%m%d-%H%M", localtime(&t));
snprintf(output_file, PATH_MAX, "%s/bootchart-%s.svg", arg_output_path, datestr);
of = fopen(output_file, "w");
}
if (!of) {
fprintf(stderr, "opening output file '%s': %m\n", output_file);
exit (EXIT_FAILURE);
}
svg_do(build);
fprintf(stderr, "systemd-bootchart wrote %s\n", output_file);
do_journal_append(output_file);
if (of)
fclose(of);
closedir(proc);
if (sysfd >= 0)
close(sysfd);
/* nitpic cleanups */
ps = ps_first->next_ps;
while (ps->next_ps) {
struct ps_struct *old;
old = ps;
old->sample = ps->first;
ps = ps->next_ps;
while (old->sample->next) {
struct ps_sched_struct *oldsample = old->sample;
old->sample = old->sample->next;
free(oldsample);
}
free(old->sample);
free(old);
}
free(ps->sample);
free(ps);
sampledata = head;
while (sampledata->link_prev) {
struct list_sample_data *old_sampledata = sampledata;
sampledata = sampledata->link_prev;
free(old_sampledata);
}
free(sampledata);
/* don't complain when overrun once, happens most commonly on 1st sample */
if (overrun > 1)
fprintf(stderr, "systemd-boochart: Warning: sample time overrun %i times\n", overrun);
return 0;
}
int main(int argc, char *argv[]) {
_cleanup_free_ char *build = NULL;
struct sigaction sig;
struct ps_struct *ps;
char output_file[PATH_MAX];
char datestr[200];
time_t t = 0;
const char *fn;
_cleanup_fclose_ FILE *f;
int gind;
int i, r;
char *init = NULL, *output = NULL;
struct rlimit rlim;
const ConfigTableItem items[] = {
{ "Bootchart", "Samples", config_parse_int, 0, &arg_samples_len },
{ "Bootchart", "Frequency", config_parse_double, 0, &arg_hz },
{ "Bootchart", "Relative", config_parse_bool, 0, &arg_relative },
{ "Bootchart", "Filter", config_parse_bool, 0, &arg_filter },
{ "Bootchart", "Output", config_parse_path, 0, &output },
{ "Bootchart", "Init", config_parse_path, 0, &init },
{ "Bootchart", "PlotMemoryUsage", config_parse_bool, 0, &arg_pss },
{ "Bootchart", "PlotEntropyGraph", config_parse_bool, 0, &arg_entropy },
{ "Bootchart", "ScaleX", config_parse_double, 0, &arg_scale_x },
{ "Bootchart", "ScaleY", config_parse_double, 0, &arg_scale_y },
{ NULL, NULL, NULL, 0, NULL }
};
fn = "/etc/systemd/bootchart.conf";
f = fopen(fn, "re");
if (f) {
r = config_parse(fn, f, NULL, config_item_table_lookup, (void*) items, true, NULL);
if (r < 0)
log_warning("Failed to parse configuration file: %s", strerror(-r));
if (init != NULL)
strscpy(arg_init_path, sizeof(arg_init_path), init);
if (output != NULL)
strscpy(arg_output_path, sizeof(arg_output_path), output);
}
while (1) {
static struct option opts[] = {
{"rel", no_argument, NULL, 'r'},
{"freq", required_argument, NULL, 'f'},
{"samples", required_argument, NULL, 'n'},
{"pss", no_argument, NULL, 'p'},
{"output", required_argument, NULL, 'o'},
{"init", required_argument, NULL, 'i'},
{"no-filter", no_argument, NULL, 'F'},
{"cmdline", no_argument, NULL, 'C'},
{"help", no_argument, NULL, 'h'},
{"scale-x", required_argument, NULL, 'x'},
{"scale-y", required_argument, NULL, 'y'},
{"entropy", no_argument, NULL, 'e'},
{NULL, 0, NULL, 0}
};
gind = 0;
i = getopt_long(argc, argv, "erpf:n:o:i:FChx:y:", opts, &gind);
if (i == -1)
break;
switch (i) {
case 'r':
arg_relative = true;
break;
case 'f':
r = safe_atod(optarg, &arg_hz);
if (r < 0)
log_warning("failed to parse --freq/-f argument '%s': %s",
optarg, strerror(-r));
break;
case 'F':
arg_filter = false;
break;
case 'C':
arg_show_cmdline = true;
break;
case 'n':
r = safe_atoi(optarg, &arg_samples_len);
if (r < 0)
log_warning("failed to parse --samples/-n argument '%s': %s",
optarg, strerror(-r));
break;
case 'o':
path_kill_slashes(optarg);
strscpy(arg_output_path, sizeof(arg_output_path), optarg);
break;
case 'i':
path_kill_slashes(optarg);
strscpy(arg_init_path, sizeof(arg_init_path), optarg);
break;
case 'p':
arg_pss = true;
break;
case 'x':
r = safe_atod(optarg, &arg_scale_x);
if (r < 0)
log_warning("failed to parse --scale-x/-x argument '%s': %s",
optarg, strerror(-r));
break;
case 'y':
r = safe_atod(optarg, &arg_scale_y);
if (r < 0)
log_warning("failed to parse --scale-y/-y argument '%s': %s",
optarg, strerror(-r));
break;
case 'e':
arg_entropy = true;
break;
case 'h':
fprintf(stderr, "Usage: %s [OPTIONS]\n", argv[0]);
fprintf(stderr, " --rel, -r Record time relative to recording\n");
fprintf(stderr, " --freq, -f f Sample frequency [%f]\n", arg_hz);
fprintf(stderr, " --samples, -n N Stop sampling at [%d] samples\n", arg_samples_len);
fprintf(stderr, " --scale-x, -x N Scale the graph horizontally [%f] \n", arg_scale_x);
fprintf(stderr, " --scale-y, -y N Scale the graph vertically [%f] \n", arg_scale_y);
fprintf(stderr, " --pss, -p Enable PSS graph (CPU intensive)\n");
fprintf(stderr, " --entropy, -e Enable the entropy_avail graph\n");
fprintf(stderr, " --output, -o [PATH] Path to output files [%s]\n", arg_output_path);
fprintf(stderr, " --init, -i [PATH] Path to init executable [%s]\n", arg_init_path);
fprintf(stderr, " --no-filter, -F Disable filtering of processes from the graph\n");
fprintf(stderr, " that are of less importance or short-lived\n");
fprintf(stderr, " --cmdline, -C Display the full command line with arguments\n");
fprintf(stderr, " of processes, instead of only the process name\n");
fprintf(stderr, " --help, -h Display this message\n");
fprintf(stderr, "See bootchart.conf for more information.\n");
exit (EXIT_SUCCESS);
break;
default:
break;
}
}
if (arg_samples_len > MAXSAMPLES) {
fprintf(stderr, "Error: samples exceeds maximum\n");
exit(EXIT_FAILURE);
}
if (arg_hz <= 0.0) {
fprintf(stderr, "Error: Frequency needs to be > 0\n");
exit(EXIT_FAILURE);
}
/*
* If the kernel executed us through init=/usr/lib/systemd/systemd-bootchart, then
* fork:
* - parent execs executable specified via init_path[] (/sbin/init by default) as pid=1
* - child logs data
*/
if (getpid() == 1) {
if (fork()) {
/* parent */
execl(arg_init_path, arg_init_path, NULL);
}
}
argv[0][0] = '@';
rlim.rlim_cur = 4096;
rlim.rlim_max = 4096;
(void) setrlimit(RLIMIT_NOFILE, &rlim);
/* start with empty ps LL */
ps_first = calloc(1, sizeof(struct ps_struct));
if (!ps_first) {
perror("calloc(ps_struct)");
exit(EXIT_FAILURE);
}
/* handle TERM/INT nicely */
memset(&sig, 0, sizeof(struct sigaction));
sig.sa_handler = signal_handler;
sigaction(SIGHUP, &sig, NULL);
interval = (1.0 / arg_hz) * 1000000000.0;
log_uptime();
/* main program loop */
while (!exiting) {
int res;
double sample_stop;
struct timespec req;
time_t newint_s;
long newint_ns;
double elapsed;
double timeleft;
sampletime[samples] = gettime_ns();
if (!of && (access(arg_output_path, R_OK|W_OK|X_OK) == 0)) {
t = time(NULL);
strftime(datestr, sizeof(datestr), "%Y%m%d-%H%M", localtime(&t));
snprintf(output_file, PATH_MAX, "%s/bootchart-%s.svg", arg_output_path, datestr);
of = fopen(output_file, "w");
}
if (sysfd < 0)
sysfd = open("/sys", O_RDONLY);
if (!build)
parse_env_file("/etc/os-release", NEWLINE,
"PRETTY_NAME", &build,
NULL);
/* wait for /proc to become available, discarding samples */
if (!(graph_start > 0.0))
log_uptime();
else
log_sample(samples);
sample_stop = gettime_ns();
elapsed = (sample_stop - sampletime[samples]) * 1000000000.0;
timeleft = interval - elapsed;
newint_s = (time_t)(timeleft / 1000000000.0);
newint_ns = (long)(timeleft - (newint_s * 1000000000.0));
/*
* check if we have not consumed our entire timeslice. If we
* do, don't sleep and take a new sample right away.
* we'll lose all the missed samples and overrun our total
* time
*/
if ((newint_ns > 0) || (newint_s > 0)) {
req.tv_sec = newint_s;
req.tv_nsec = newint_ns;
res = nanosleep(&req, NULL);
if (res) {
if (errno == EINTR) {
/* caught signal, probably HUP! */
break;
}
perror("nanosleep()");
exit (EXIT_FAILURE);
}
} else {
overrun++;
/* calculate how many samples we lost and scrap them */
arg_samples_len = arg_samples_len + ((int)(newint_ns / interval));
}
samples++;
if (samples > arg_samples_len)
break;
}
/* do some cleanup, close fd's */
ps = ps_first;
while (ps->next_ps) {
ps = ps->next_ps;
if (ps->schedstat)
close(ps->schedstat);
if (ps->sched)
close(ps->sched);
if (ps->smaps)
fclose(ps->smaps);
}
if (!of) {
t = time(NULL);
strftime(datestr, sizeof(datestr), "%Y%m%d-%H%M", localtime(&t));
snprintf(output_file, PATH_MAX, "%s/bootchart-%s.svg", arg_output_path, datestr);
of = fopen(output_file, "w");
}
if (!of) {
fprintf(stderr, "opening output file '%s': %m\n", output_file);
exit (EXIT_FAILURE);
}
svg_do(build);
fprintf(stderr, "systemd-bootchart wrote %s\n", output_file);
if (of)
fclose(of);
closedir(proc);
if (sysfd >= 0)
close(sysfd);
/* nitpic cleanups */
ps = ps_first;
while (ps->next_ps) {
struct ps_struct *old = ps;
ps = ps->next_ps;
free(old->sample);
free(old);
}
free(ps->sample);
free(ps);
/* don't complain when overrun once, happens most commonly on 1st sample */
if (overrun > 1)
fprintf(stderr, "systemd-boochart: Warning: sample time overrun %i times\n", overrun);
return 0;
}