/*
 * bootchart.c
 *
 * Copyright (c) 2009 Intel Coproration
 * Authors:
 *   Auke Kok <auke-jan.h.kok@intel.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; version 2
 * of the License.
 */


#include <sys/time.h>
#include <sys/types.h>
#include <sys/resource.h>
#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <getopt.h>
#include <limits.h>
#include <errno.h>


#include "bootchart.h"

double graph_start;
double log_start;
double sampletime[MAXSAMPLES];
struct ps_struct *ps_first;
struct block_stat_struct blockstat[MAXSAMPLES];
int entropy_avail[MAXSAMPLES];
struct cpu_stat_struct cpustat[MAXCPUS];
int pscount;
int cpus;
double interval;
FILE *of;
int overrun = 0;
static int exiting = 0;

/* graph defaults */
int entropy = 0;
int initcall = 1;
int relative;
int filter = 1;
int pss = 0;
int samples;
int len = 500; /* we record len+1 (1 start sample) */
double hz = 25.0;   /* 20 seconds log time */
double scale_x = 100.0; /* 100px = 1sec */
double scale_y = 20.0;  /* 16px = 1 process bar */

char init_path[PATH_MAX] = "/sbin/init";
char output_path[PATH_MAX] = "/var/log";

static struct rlimit rlim;

static void signal_handler(int sig)
{
	if (sig++)
		sig--;
	exiting = 1;
}


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;
}