void ca_css_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
				unsigned long event, int is_kernel)
{
	struct oprofile_cpu_buffer * cpu_buf = &cpu_buffer[smp_processor_id()];

	if (!ca_css_depth) {
		log_sample(cpu_buf, pc, is_kernel, event);
		return;
	}

	if (!oprofile_begin_trace(cpu_buf))
		return;

	if (log_sample(cpu_buf, pc, is_kernel, event)) {
		if (cpu_buf->ca_css_interval++ > ca_css_interval) {
			if ( (ca_css_tgid && cpu_buf->last_task->tgid == ca_css_tgid)
			||   (ca_css_ppid && cpu_buf->last_task->parent
				 && cpu_buf->last_task->parent->pid == ca_css_ppid) ) 
			{
				oprofile_ops.ca_css(regs, ca_css_depth, cpu_buf->last_task);
				cpu_buf->ca_css_interval = 0;
			}
		}
	}

	oprofile_end_trace(cpu_buf);

}
Exemple #2
0
void oprofile_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
                             unsigned long event, int is_kernel)
{
    struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(cpu_buffer);

    if (!backtrace_depth) {
        log_sample(cpu_buf, pc, is_kernel, event);
        return;
    }

    if (!oprofile_begin_trace(cpu_buf))
        return;

    /* if log_sample() fail we can't backtrace since we lost the source
     * of this event */
    if (log_sample(cpu_buf, pc, is_kernel, event))
        oprofile_ops.backtrace(regs, backtrace_depth);
    oprofile_end_trace(cpu_buf);
}
Exemple #3
0
int main(int argc, char **argv) {
    util::time::time_utility::update();

    tquerystring_sample();
    hash_sample();
    random_sample();
    log_sample();
    cmd_option_sample();
    return 0;
}
Exemple #4
0
void oprofile_add_sample(struct pt_regs * const regs, unsigned long event)
{
	struct oprofile_cpu_buffer * cpu_buf = &cpu_buffer[smp_processor_id()];
	unsigned long pc = profile_pc(regs);
	int is_kernel = !user_mode(regs);

	if (!backtrace_depth) {
		log_sample(cpu_buf, pc, is_kernel, event);
		return;
	}

	if (!oprofile_begin_trace(cpu_buf))
		return;

	/* if log_sample() fail we can't backtrace since we lost the source
	 * of this event */
	if (log_sample(cpu_buf, pc, is_kernel, event))
		oprofile_ops.backtrace(regs, backtrace_depth);
	oprofile_end_trace(cpu_buf);
}
Exemple #5
0
static inline void
__oprofile_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
			  unsigned long event, int is_kernel)
{
	struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(cpu_buffer);
	unsigned long backtrace = oprofile_backtrace_depth;

	
	if (!log_sample(cpu_buf, pc, backtrace, is_kernel, event))
		
		return;

	if (!backtrace)
		return;

	oprofile_begin_trace(cpu_buf);
	oprofile_ops.backtrace(regs, backtrace);
	oprofile_end_trace(cpu_buf);
}
static inline void
__oprofile_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
			  unsigned long event, int is_kernel)
{
	struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(op_cpu_buffer);
	unsigned long backtrace = oprofile_backtrace_depth;

	/*
	 * if log_sample() fail we can't backtrace since we lost the
	 * source of this event
	 */
	if (!log_sample(cpu_buf, pc, backtrace, is_kernel, event))
		/* failed */
		return;

	if (!backtrace)
		return;

	oprofile_begin_trace(cpu_buf);
	oprofile_ops.backtrace(regs, backtrace);
	oprofile_end_trace(cpu_buf);
}
Exemple #7
0
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;
}
void oprofile_add_pc(unsigned long pc, int is_kernel, unsigned long event)
{
	struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(op_cpu_buffer);
	log_sample(cpu_buf, pc, 0, is_kernel, event);
}
Exemple #9
0
void oprofile_add_pc(unsigned long pc, int is_kernel, unsigned long event)
{
	struct oprofile_cpu_buffer * cpu_buf = &cpu_buffer[smp_processor_id()];
	log_sample(cpu_buf, pc, is_kernel, event);
}
Exemple #10
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;
}
Exemple #11
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;
}
Exemple #12
0
int main(int argc, char *argv[]) {
        static struct list_sample_data *sampledata;
        _cleanup_closedir_ DIR *proc = NULL;
        _cleanup_free_ char *build = NULL;
        _cleanup_fclose_ FILE *of = NULL;
        _cleanup_close_ int sysfd = -1;
        int schfd;
        struct ps_struct *ps_first;
        double graph_start;
        double log_start;
        double interval;
        char output_file[PATH_MAX];
        char datestr[200];
        int pscount = 0;
        int n_cpus = 0;
        int overrun = 0;
        time_t t = 0;
        int r, samples;
        struct ps_struct *ps;
        struct rlimit rlim;
        struct list_sample_data *head;
        struct sigaction sig = {
                .sa_handler = signal_handler,
        };

        parse_conf();

        r = parse_argv(argc, argv);
        if (r < 0)
                return EXIT_FAILURE;

        if (r == 0)
                return EXIT_SUCCESS;

        /*
         * If the kernel executed us through init=/usr/lib/systemd/systemd-bootchart, then
         * fork:
         * - parent execs executable specified via init_path[] (/usr/lib/systemd/systemd 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);

        schfd = open("/proc/sys/kernel/sched_schedstats", O_WRONLY);
        if (schfd >= 0) {
                write(schfd, "1\n", 2);
                close(schfd);
        }

        /* start with empty ps LL */
        ps_first = new0(struct ps_struct, 1);
        if (!ps_first) {
                log_oom();
                return EXIT_FAILURE;
        }

        /* handle TERM/INT nicely */
        sigaction(SIGHUP, &sig, NULL);

        interval = (1.0 / arg_hz) * 1000000000.0;

        if (arg_relative)
                graph_start = log_start = gettime_ns();
        else {
                struct timespec n;
                double uptime;

                clock_gettime(clock_boottime_or_monotonic(), &n);
                uptime = (n.tv_sec + (n.tv_nsec / (double) NSEC_PER_SEC));

                log_start = gettime_ns();
                graph_start = log_start - uptime;
        }

        if (graph_start < 0.0) {
                log_error("Failed to setup graph start time.\n\n"
                          "The system uptime probably includes time that the system was suspended. "
                          "Use --rel to bypass this issue.");
                return EXIT_FAILURE;
        }

        LIST_HEAD_INIT(head);

        /* main program loop */
        for (samples = 0; !exiting && samples < arg_samples_len; samples++) {
                int res;
                double sample_stop;
                double elapsed;
                double timeleft;

                sampledata = new0(struct list_sample_data, 1);
                if (sampledata == NULL) {
                        log_oom();
                        return EXIT_FAILURE;
                }

                sampledata->sampletime = gettime_ns();
                sampledata->counter = samples;

                if (sysfd < 0)
                        sysfd = open("/sys", O_RDONLY|O_CLOEXEC);

                if (!build) {
                        if (parse_env_file("/etc/os-release", NEWLINE, "PRETTY_NAME", &build, NULL) == -ENOENT)
                                parse_env_file("/usr/lib/os-release", NEWLINE, "PRETTY_NAME", &build, NULL);
                }

                if (proc)
                        rewinddir(proc);
                else
                        proc = opendir("/proc");

                /* wait for /proc to become available, discarding samples */
                if (proc) {
                        r = log_sample(proc, samples, ps_first, &sampledata, &pscount, &n_cpus);
                        if (r < 0)
                                return EXIT_FAILURE;
                }

                sample_stop = gettime_ns();

                elapsed = (sample_stop - sampledata->sampletime) * 1000000000.0;
                timeleft = interval - elapsed;

                /*
                 * 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 (timeleft > 0) {
                        struct timespec req;

                        req.tv_sec = (time_t)(timeleft / 1000000000.0);
                        req.tv_nsec = (long)(timeleft - (req.tv_sec * 1000000000.0));

                        res = nanosleep(&req, NULL);
                        if (res) {
                                if (errno == EINTR)
                                        /* caught signal, probably HUP! */
                                        break;
                                log_error_errno(errno, "nanosleep() failed: %m");
                                return EXIT_FAILURE;
                        }
                } else {
                        overrun++;
                        /* calculate how many samples we lost and scrap them */
                        arg_samples_len -= (int)(-timeleft / interval);
                }
                LIST_PREPEND(link, head, sampledata);
        }

        /* do some cleanup, close fd's */
        ps = ps_first;
        while (ps->next_ps) {
                ps = ps->next_ps;
                ps->schedstat = safe_close(ps->schedstat);
                ps->sched = safe_close(ps->sched);
                ps->smaps = safe_fclose(ps->smaps);
        }

        if (!of) {
                t = time(NULL);
                r = strftime(datestr, sizeof(datestr), "%Y%m%d-%H%M", localtime(&t));
                assert_se(r > 0);

                snprintf(output_file, PATH_MAX, "%s/bootchart-%s.svg", arg_output_path, datestr);
                of = fopen(output_file, "we");
        }

        if (!of) {
                log_error("Error opening output file '%s': %m\n", output_file);
                return EXIT_FAILURE;
        }

        r = svg_do(of, strna(build), head, ps_first,
                   samples, pscount, n_cpus, graph_start,
                   log_start, interval, overrun);

        if (r < 0) {
                log_error_errno(r, "Error generating svg file: %m");
                return EXIT_FAILURE;
        }

        log_info("systemd-bootchart wrote %s\n", output_file);

        r = do_journal_append(output_file);
        if (r < 0)
                return EXIT_FAILURE;

        /* 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->cgroup);
                free(old->sample);
                free(old);
        }

        free(ps->cgroup);
        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)
                log_warning("systemd-bootchart: sample time overrun %i times\n", overrun);

        return 0;
}