oprof_start.cpp - Android社区 - https://www.androidos.net.cn/

/**
 * @file oprof_start.cpp
 * The GUI start main class
 *
 * @remark Copyright 2002 OProfile authors
 * @remark Read the file COPYING
 *
 * @author Philippe Elie
 * @author John Levon
 */

#include <sys/stat.h>
#include <unistd.h>

#include <ctime>
#include <cstdio>
#include <cmath>
#include <sstream>
#include <iostream>
#include <fstream>
#include <algorithm>

#include <qlineedit.h>
#include <qlistview.h>
#include <qcombobox.h>
#include <qlistbox.h>
#include <qfiledialog.h>
#include <qbuttongroup.h>
#include <qcheckbox.h>
#include <qtabwidget.h>
#include <qmessagebox.h>
#include <qvalidator.h>
#include <qlabel.h>
#include <qpushbutton.h>
#include <qheader.h>

#include "config.h"
#include "oprof_start.h"
#include "op_config.h"
#include "op_config_24.h"
#include "string_manip.h"
#include "op_cpufreq.h"
#include "op_alloc_counter.h"
#include "oprof_start_util.h"
#include "file_manip.h"

#include "op_hw_config.h"

using namespace std;

static char const * green_xpm[] = {
"16 16 2 1",
" 	c None",
".	c #00FF00",
"    .......     ",
"  ...........   ",
" .............  ",
" .............  ",
"............... ",
"............... ",
"............... ",
"............... ",
"............... ",
"............... ",
"............... ",
" .............  ",
" .............  ",
"  ...........   ",
"    .......     ",
"                " };

static char const * red_xpm[] = {
"16 16 2 1",
" 	c None",
".	c #FF0000",
"    .......     ",
"  ...........   ",
" .............  ",
" .............  ",
"............... ",
"............... ",
"............... ",
"............... ",
"............... ",
"............... ",
"............... ",
" .............  ",
" .............  ",
"  ...........   ",
"    .......     ",
"                " };

static QPixmap * green_pixmap;
static QPixmap * red_pixmap;

op_event_descr::op_event_descr()
	:
	counter_mask(0),
	val(0),
	unit(0),
	min_count(0)
{
}

oprof_start::oprof_start()
	:
	oprof_start_base(0, 0, false, 0),
	event_count_validator(new QIntValidator(event_count_edit)),
	current_event(0),
	cpu_speed(op_cpu_frequency()),
	total_nr_interrupts(0)
{
	green_pixmap = new QPixmap(green_xpm);
	red_pixmap = new QPixmap(red_xpm);
	vector<string> args;
	args.push_back("--init");

if (do_exec_command(OP_BINDIR "/opcontrol", args))
		exit(EXIT_FAILURE);

cpu_type = op_get_cpu_type();
	op_nr_counters = op_get_nr_counters(cpu_type);

if (cpu_type == CPU_TIMER_INT) {
		setup_config_tab->removePage(counter_setup_page);
	} else {
		fill_events();
	}

op_interface interface = op_get_interface();
	if (interface == OP_INTERFACE_NO_GOOD) {
		QMessageBox::warning(this, 0, "Couldn't determine kernel"
		                     " interface version");
		exit(EXIT_FAILURE);
	}
	bool is_26 = interface == OP_INTERFACE_26;

if (is_26) {
		note_table_size_edit->hide();
		note_table_size_label->hide();
		if (!op_file_readable("/dev/oprofile/backtrace_depth")) {
			callgraph_depth_label->hide();
			callgraph_depth_edit->hide();
		}
	} else {
		callgraph_depth_label->hide();
		callgraph_depth_edit->hide();
		buffer_watershed_label->hide();
		buffer_watershed_edit->hide();
		cpu_buffer_size_label->hide();
		cpu_buffer_size_edit->hide();
	}

// setup the configuration page.
	kernel_filename_edit->setText(config.kernel_filename.c_str());

no_vmlinux->setChecked(config.no_kernel);

buffer_size_edit->setText(QString().setNum(config.buffer_size));
	buffer_watershed_edit->setText(QString().setNum(config.buffer_watershed));
	cpu_buffer_size_edit->setText(QString().setNum(config.cpu_buffer_size));
	note_table_size_edit->setText(QString().setNum(config.note_table_size));
	callgraph_depth_edit->setText(QString().setNum(config.callgraph_depth));
	verbose->setChecked(config.verbose);
	separate_lib_cb->setChecked(config.separate_lib);
	separate_kernel_cb->setChecked(config.separate_kernel);
	separate_cpu_cb->setChecked(config.separate_cpu);
	separate_thread_cb->setChecked(config.separate_thread);

// the unit mask check boxes
	hide_masks();

event_count_edit->setValidator(event_count_validator);
	QIntValidator * iv;
	iv = new QIntValidator(OP_MIN_BUF_SIZE, OP_MAX_BUF_SIZE, buffer_size_edit);
	buffer_size_edit->setValidator(iv);
	iv = new QIntValidator(OP_MIN_NOTE_TABLE_SIZE, OP_MAX_NOTE_TABLE_SIZE, note_table_size_edit);
	note_table_size_edit->setValidator(iv);
	iv = new QIntValidator(0, INT_MAX, callgraph_depth_edit);
	callgraph_depth_edit->setValidator(iv);
	iv = new QIntValidator(0, INT_MAX, buffer_watershed_edit);
	buffer_watershed_edit->setValidator(iv);
	iv = new QIntValidator(0, OP_MAX_CPU_BUF_SIZE, cpu_buffer_size_edit);
	cpu_buffer_size_edit->setValidator(iv);

// daemon status timer
	startTimer(5000);
	timerEvent(0);

resize(minimumSizeHint());

// force the pixmap re-draw
	event_selected();
}

void oprof_start::fill_events()
{
	// we need to build the event descr stuff before loading the
	// configuration because we use locate_event to get an event descr
	// from its name.
	struct list_head * pos;
	struct list_head * events = op_events(cpu_type);

list_for_each(pos, events) {
		struct op_event * event = list_entry(pos, struct op_event, event_next);

op_event_descr descr;

descr.counter_mask = event->counter_mask;
		descr.val = event->val;
		if (event->unit->num) {
			descr.unit = event->unit;
		} else {
			descr.unit = 0;
		}

descr.name = event->name;
		descr.help_str = event->desc;
		descr.min_count = event->min_count;

for (uint ctr = 0; ctr < op_nr_counters; ++ctr) {
			uint count;

if (!(descr.counter_mask & (1 << ctr)))
				continue;

if (cpu_type == CPU_RTC) {
				count = 1024;
			} else {
				/* setting to cpu Hz / 2000 gives a safe value for
				 * all events, and a good one for most.
				 */
				if (cpu_speed)
					count = int(cpu_speed * 500);
				else
					count = descr.min_count * 100;
			}

event_cfgs[descr.name].count = count;
			event_cfgs[descr.name].umask = 0;
			if (descr.unit)
				event_cfgs[descr.name].umask = descr.unit->default_mask;
			event_cfgs[descr.name].os_ring_count = 1;
			event_cfgs[descr.name].user_ring_count = 1;
		}

v_events.push_back(descr);
	}

events_list->header()->hide();
	events_list->setSorting(-1);

fill_events_listbox();

read_set_events();

// FIXME: why this ?
	if (cpu_type == CPU_RTC)
		events_list->setCurrentItem(events_list->firstChild());

load_config_file();
}

namespace {

/// find the first item with the given text in column 0 or return NULL
QListViewItem * findItem(QListView * view, char const * name)
{
	// Qt 2.3.1 does not have QListView::findItem()
	QListViewItem * item = view->firstChild();

while (item && strcmp(item->text(0).latin1(), name))
		item = item->nextSibling();

return item;
}

};

void oprof_start::setup_default_event()
{
	struct op_default_event_descr descr;
	op_default_event(cpu_type, &descr);

event_cfgs[descr.name].umask = descr.um;
	event_cfgs[descr.name].count = descr.count;
	event_cfgs[descr.name].user_ring_count = 1;
	event_cfgs[descr.name].os_ring_count = 1;

QListViewItem * item = findItem(events_list, descr.name);
	if (item)
		item->setSelected(true);
}

void oprof_start::read_set_events()
{
	string name = get_config_filename(".oprofile/daemonrc");

ifstream in(name.c_str());

if (!in) {
		setup_default_event();
		return;
	}

string str;

bool one_enabled = false;

while (getline(in, str)) {
		string const val = split(str, '=');
		string const name = str;

if (!is_prefix(name, "CHOSEN_EVENTS_"))
			continue;

one_enabled = true;

// CHOSEN_EVENTS_#nr=CPU_CLK_UNHALTED:10000:0:1:1
		vector<string> parts = separate_token(val, ':');

if (parts.size() != 5 && parts.size() != 2) {
			cerr << "invalid configuration file\n";
			// FIXME
			exit(EXIT_FAILURE);
		}

string ev_name = parts[0];
		event_cfgs[ev_name].count =
			op_lexical_cast<unsigned int>(parts[1]);

// CPU_CLK_UNHALTED:10000 is also valid
		if (parts.size() == 5) {
			event_cfgs[ev_name].umask =
				op_lexical_cast<unsigned int>(parts[2]);
			event_cfgs[ev_name].user_ring_count =
				op_lexical_cast<unsigned int>(parts[3]);
			event_cfgs[ev_name].os_ring_count =
				op_lexical_cast<unsigned int>(parts[4]);
		} else {
			event_cfgs[ev_name].umask = 0;
			event_cfgs[ev_name].user_ring_count = 1;
			event_cfgs[ev_name].os_ring_count = 1;
		}

QListViewItem * item = findItem(events_list, ev_name.c_str());
		if (item)
			item->setSelected(true);
	}

// use default event if none set
	if (!one_enabled)
		setup_default_event();
}

void oprof_start::load_config_file()
{
	string name = get_config_filename(".oprofile/daemonrc");

ifstream in(name.c_str());
	if (!in) {
		if (!check_and_create_config_dir())
			return;

ofstream out(name.c_str());
		if (!out) {
			QMessageBox::warning(this, 0, "Unable to open configuration "
				"file ~/.oprofile/daemonrc");
		}
		return;
	}

in >> config;
}

// user request a "normal" exit so save the config file.
void oprof_start::accept()
{
	// record the previous settings
	record_selected_event_config();

save_config();

QDialog::accept();
}

void oprof_start::closeEvent(QCloseEvent *)
{
	accept();
}

void oprof_start::timerEvent(QTimerEvent *)
{
	static time_t last = time(0);

daemon_status dstat;

flush_profiler_data_btn->setEnabled(dstat.running);
	stop_profiler_btn->setEnabled(dstat.running);
	start_profiler_btn->setEnabled(!dstat.running);
	reset_sample_files_btn->setEnabled(!dstat.running);

if (!dstat.running) {
		daemon_label->setText("Profiler is not running.");
		return;
	}

ostringstream ss;
	ss << "Profiler running:";

time_t curr = time(0);
	total_nr_interrupts += dstat.nr_interrupts;

if (curr - last)
		ss << " (" << dstat.nr_interrupts / (curr - last) << " interrupts / second, total " << total_nr_interrupts << ")";

daemon_label->setText(ss.str().c_str());

last = curr;
}

void oprof_start::fill_events_listbox()
{
	setUpdatesEnabled(false);

for (vector<op_event_descr>::reverse_iterator cit = v_events.rbegin();
	     cit != v_events.rend(); ++cit) {
		new QListViewItem(events_list, cit->name.c_str());
	}

setUpdatesEnabled(true);
	update();
}

void oprof_start::display_event(op_event_descr const & descr)
{
	setUpdatesEnabled(false);

setup_unit_masks(descr);
	os_ring_count_cb->setEnabled(true);
	user_ring_count_cb->setEnabled(true);
	event_count_edit->setEnabled(true);

event_setting & cfg = event_cfgs[descr.name];

os_ring_count_cb->setChecked(cfg.os_ring_count);
	user_ring_count_cb->setChecked(cfg.user_ring_count);
	QString count_text;
	count_text.setNum(cfg.count);
	event_count_edit->setText(count_text);
	event_count_validator->setRange(descr.min_count, max_perf_count());

setUpdatesEnabled(true);
	update();
}

bool oprof_start::is_selectable_event(QListViewItem * item)
{
	if (item->isSelected())
		return true;

selected_events.insert(item);

bool ret = false;
	if (alloc_selected_events())
		ret = true;

selected_events.erase(item);

return ret;
}

void oprof_start::draw_event_list()
{
	QListViewItem * cur;
	for (cur = events_list->firstChild(); cur; cur = cur->nextSibling()) {
		if (is_selectable_event(cur))
			cur->setPixmap(0, *green_pixmap);
		else
			cur->setPixmap(0, *red_pixmap);
	}
}

bool oprof_start::alloc_selected_events() const
{
	vector<op_event const *> events;

set<QListViewItem *>::const_iterator it;
	for (it = selected_events.begin(); it != selected_events.end(); ++it)
		events.push_back(find_event_by_name((*it)->text(0).latin1(),0,0));

size_t * map =
		map_event_to_counter(&events[0], events.size(), cpu_type);

if (!map)
		return false;

free(map);
	return true;
}

void oprof_start::event_selected()
{
	// The deal is simple: QT lack of a way to know what item was the last
	// (de)selected item so we record a set of selected items and diff
	// it in the appropriate way with the previous list of selected items.

set<QListViewItem *> current_selection;
	QListViewItem * cur;
	for (cur = events_list->firstChild(); cur; cur = cur->nextSibling()) {
		if (cur->isSelected())
			current_selection.insert(cur);
	}

// First remove the deselected item.
	vector<QListViewItem *> new_deselected;
	set_difference(selected_events.begin(), selected_events.end(),
		       current_selection.begin(), current_selection.end(),
		       back_inserter(new_deselected));
	vector<QListViewItem *>::const_iterator it;
	for (it = new_deselected.begin(); it != new_deselected.end(); ++it)
		selected_events.erase(*it);

// Now try to add the newly selected item if enough HW resource exists
	vector<QListViewItem *> new_selected;
	set_difference(current_selection.begin(), current_selection.end(),
		       selected_events.begin(), selected_events.end(),
		       back_inserter(new_selected));
	for (it = new_selected.begin(); it != new_selected.end(); ++it) {
		selected_events.insert(*it);
		if (!alloc_selected_events()) {
			(*it)->setSelected(false);
			selected_events.erase(*it);
		} else {
			current_event = *it;
		}
	}

draw_event_list();

if (current_event)
		display_event(locate_event(current_event->text(0).latin1()));
}

void oprof_start::event_over(QListViewItem * item)
{
	op_event_descr const & descr = locate_event(item->text(0).latin1());

string help_str = descr.help_str.c_str();
	if (!is_selectable_event(item)) {
		help_str += " conflicts with:";

set<QListViewItem *>::const_iterator it;
		for (it = selected_events.begin(); 
		     it != selected_events.end(); ) {
			QListViewItem * temp = *it;
			selected_events.erase(it++);
			if (is_selectable_event(item)) {
				help_str += " ";
				help_str += temp->text(0).latin1();
			}
			selected_events.insert(temp);
		}
	}

event_help_label->setText(help_str.c_str());
}

/// select the kernel image filename
void oprof_start::choose_kernel_filename()
{
	string name = kernel_filename_edit->text().latin1();
	string result = do_open_file_or_dir(name, false);

if (!result.empty())
		kernel_filename_edit->setText(result.c_str());
}

// this record the current selected event setting in the event_cfg[] stuff.
// FIXME: need validation?
void oprof_start::record_selected_event_config()
{
	if (!current_event)
		return;

string name(current_event->text(0).latin1());

event_setting & cfg = event_cfgs[name];
	op_event_descr const & curr = locate_event(name);

cfg.count = event_count_edit->text().toUInt();
	cfg.os_ring_count = os_ring_count_cb->isChecked();
	cfg.user_ring_count = user_ring_count_cb->isChecked();
	cfg.umask = get_unit_mask(curr);
}

// validate and save the configuration (The qt validator installed
// are not sufficient to do the validation)
bool oprof_start::record_config()
{
	config.kernel_filename = kernel_filename_edit->text().latin1();
	config.no_kernel = no_vmlinux->isChecked();

uint temp = buffer_size_edit->text().toUInt();
	if (temp < OP_MIN_BUF_SIZE || temp > OP_MAX_BUF_SIZE) {
		ostringstream error;

error << "buffer size out of range: " << temp
		      << " valid range is [" << OP_MIN_BUF_SIZE << ", "
		      << OP_MAX_BUF_SIZE << "]";