/*
* proc_pmc.c
* Copyright (C) 2001 Mike Corrigan & Dave Engebretsen IBM Corporation
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/* Change Activity:
* 2001 : mikec : Created
* 2001/06/05 : engebret : Software event count support.
* 2001/08/03 : trautman : Added PCI Flight Recorder
* End Change Activity
*/
#include <asm/proc_fs.h>
#include <asm/paca.h>
#include <asm/iSeries/ItLpPaca.h>
#include <asm/iSeries/ItLpQueue.h>
#include <asm/iSeries/HvCallXm.h>
#include <asm/iSeries/IoHriMainStore.h>
#include <asm/processor.h>
#include <asm/time.h>
#include <asm/iSeries/LparData.h>
#include <linux/config.h>
#include <linux/proc_fs.h>
#include <linux/spinlock.h>
#include <asm/pmc.h>
#include <asm/uaccess.h>
#include <asm/naca.h>
#include <asm/rtas.h>
#include <asm/perfmon.h>
/* pci Flight Recorder AHT */
extern void proc_pciFr_init(struct proc_dir_entry *proc_ppc64_root);
static int proc_pmc_control_mode = 0;
struct proc_dir_entry *proc_ppc64_root = NULL;
static struct proc_dir_entry *proc_ppc64_pmc_root = NULL;
static struct proc_dir_entry *proc_ppc64_pmc_system_root = NULL;
static struct proc_dir_entry *proc_ppc64_pmc_cpu_root[NR_CPUS] = {NULL, };
spinlock_t proc_ppc64_lock;
static int proc_ppc64_page_read(char *page, char **start, off_t off,
int count, int *eof, void *data);
static void proc_ppc64_create_paca(int num, struct proc_dir_entry *paca_dir);
void proc_ppc64_create_smt(void);
int proc_ppc64_pmc_find_file(void *data);
int proc_ppc64_pmc_read(char *page, char **start, off_t off,
int count, int *eof, char *buffer);
int proc_ppc64_pmc_stab_read(char *page, char **start, off_t off,
int count, int *eof, void *data);
int proc_ppc64_pmc_htab_read(char *page, char **start, off_t off,
int count, int *eof, void *data);
int proc_ppc64_pmc_profile_read(char *page, char **start, off_t off,
int count, int *eof, void *data);
int proc_ppc64_pmc_profile_read(char *page, char **start, off_t off,
int count, int *eof, void *data);
int proc_ppc64_pmc_hw_read(char *page, char **start, off_t off,
int count, int *eof, void *data);
static struct proc_dir_entry *pmc_proc_root = NULL;
int proc_get_lpevents( char *page, char **start, off_t off, int count, int *eof, void *data);
int proc_reset_lpevents( struct file *file, const char *buffer, unsigned long count, void *data);
int proc_get_titanTod( char *page, char **start, off_t off, int count, int *eof, void *data);
int proc_pmc_get_control( char *page, char **start, off_t off, int count, int *eof, void *data);
int proc_pmc_set_control( struct file *file, const char *buffer, unsigned long count, void *data);
int proc_pmc_set_mmcr0( struct file *file, const char *buffer, unsigned long count, void *data);
int proc_pmc_set_mmcr1( struct file *file, const char *buffer, unsigned long count, void *data);
int proc_pmc_set_mmcra( struct file *file, const char *buffer, unsigned long count, void *data);
int proc_pmc_set_pmc1( struct file *file, const char *buffer, unsigned long count, void *data);
int proc_pmc_set_pmc2( struct file *file, const char *buffer, unsigned long count, void *data);
int proc_pmc_set_pmc3( struct file *file, const char *buffer, unsigned long count, void *data);
int proc_pmc_set_pmc4( struct file *file, const char *buffer, unsigned long count, void *data);
int proc_pmc_set_pmc5( struct file *file, const char *buffer, unsigned long count, void *data);
int proc_pmc_set_pmc6( struct file *file, const char *buffer, unsigned long count, void *data);
int proc_pmc_set_pmc7( struct file *file, const char *buffer, unsigned long count, void *data);
int proc_pmc_set_pmc8( struct file *file, const char *buffer, unsigned long count, void *data);
static loff_t nacamap_seek( struct file *file, loff_t off, int whence);
static ssize_t nacamap_read( struct file *file, char *buf, size_t nbytes, loff_t *ppos);
static int nacamap_mmap( struct file *file, struct vm_area_struct *vma );
static struct file_operations nacamap_fops = {
llseek: nacamap_seek,
read: nacamap_read,
mmap: nacamap_mmap
};
static ssize_t read_profile(struct file *file, char *buf, size_t count, loff_t *ppos);
static ssize_t write_profile(struct file * file, const char * buf,
size_t count, loff_t *ppos);
static ssize_t read_trace(struct file *file, char *buf, size_t count, loff_t *ppos);
static ssize_t write_trace(struct file * file, const char * buf,
size_t count, loff_t *ppos);
static ssize_t read_timeslice(struct file *file, char *buf, size_t count, loff_t *ppos);
static ssize_t write_timeslice(struct file * file, const char * buf,
size_t count, loff_t *ppos);
static struct file_operations proc_profile_operations = {
read: read_profile,
write: write_profile,
};
static struct file_operations proc_trace_operations = {
read: read_trace,
write: write_trace,
};
static struct file_operations proc_timeslice_operations = {
read: read_timeslice,
write: write_timeslice,
};
extern struct perfmon_base_struct perfmon_base;
void proc_ppc64_init(void)
{
unsigned long i;
struct proc_dir_entry *ent = NULL;
char buf[256];
printk("proc_ppc64: Creating /proc/ppc64/pmc\n");
/*
* Create the root, system, and cpu directories as follows:
* /proc/ppc64/pmc/system
* /proc/ppc64/pmc/cpu0
*/
spin_lock(&proc_ppc64_lock);
if (proc_ppc64_root == NULL) {
proc_ppc64_root = proc_mkdir("ppc64", 0);
if (!proc_ppc64_root) {
spin_unlock(&proc_ppc64_lock);
return;
}
}
spin_unlock(&proc_ppc64_lock);
ent = create_proc_entry("naca", S_IFREG|S_IRUGO, proc_ppc64_root);
if ( ent ) {
ent->nlink = 1;
ent->data = naca;
ent->size = 4096;
ent->proc_fops = &nacamap_fops;
}
ent = create_proc_entry("systemcfg", S_IFREG|S_IRUGO, proc_ppc64_root);
if ( ent ) {
ent->nlink = 1;
ent->data = systemcfg;
ent->size = 4096;
ent->proc_fops = &nacamap_fops;
}
/* /proc/ppc64/paca/XX -- raw paca contents. Only readable to root */
ent = proc_mkdir("paca", proc_ppc64_root);
if (ent) {
for (i = 0; i < systemcfg->processorCount; i++)
proc_ppc64_create_paca(i, ent);
}
/* Placeholder for rtas interfaces. */
if (rtas_proc_dir == NULL) {
rtas_proc_dir = proc_mkdir("rtas", proc_ppc64_root);
}
proc_ppc64_create_smt();
/* Create the /proc/ppc64/pcifr for the Pci Flight Recorder. */
proc_pciFr_init(proc_ppc64_root);
proc_ppc64_pmc_root = proc_mkdir("pmc", proc_ppc64_root);
proc_ppc64_pmc_system_root = proc_mkdir("system", proc_ppc64_pmc_root);
for (i = 0; i < systemcfg->processorCount; i++) {
sprintf(buf, "cpu%ld", i);
proc_ppc64_pmc_cpu_root[i] = proc_mkdir(buf, proc_ppc64_pmc_root);
}
/* Create directories for the software counters. */
for (i = 0; i < systemcfg->processorCount; i++) {
ent = create_proc_entry("stab", S_IRUGO | S_IWUSR,
proc_ppc64_pmc_cpu_root[i]);
if (ent) {
ent->nlink = 1;
ent->data = (void *)proc_ppc64_pmc_cpu_root[i];
ent->read_proc = (void *)proc_ppc64_pmc_stab_read;
ent->write_proc = NULL;
}
ent = create_proc_entry("htab", S_IRUGO | S_IWUSR,
proc_ppc64_pmc_cpu_root[i]);
if (ent) {
ent->nlink = 1;
ent->data = (void *)proc_ppc64_pmc_cpu_root[i];
ent->read_proc = (void *)proc_ppc64_pmc_htab_read;
ent->write_proc = NULL;
}
}
ent = create_proc_entry("stab", S_IRUGO | S_IWUSR,
proc_ppc64_pmc_system_root);
if (ent) {
ent->nlink = 1;
ent->data = (void *)proc_ppc64_pmc_system_root;
ent->read_proc = (void *)proc_ppc64_pmc_stab_read;
ent->write_proc = NULL;
}
ent = create_proc_entry("htab", S_IRUGO | S_IWUSR,
proc_ppc64_pmc_system_root);
if (ent) {
ent->nlink = 1;
ent->data = (void *)proc_ppc64_pmc_system_root;
ent->read_proc = (void *)proc_ppc64_pmc_htab_read;
ent->write_proc = NULL;
}
ent = create_proc_entry("profile", S_IWUSR | S_IRUGO, proc_ppc64_pmc_system_root);
if (ent) {
ent->nlink = 1;
ent->proc_fops = &proc_profile_operations;
/* ent->size = (1+prof_len) * sizeof(unsigned int); */
}
ent = create_proc_entry("trace", S_IWUSR | S_IRUGO, proc_ppc64_pmc_system_root);
if (ent) {
ent->nlink = 1;
ent->proc_fops = &proc_trace_operations;
/* ent->size = (1+prof_len) * sizeof(unsigned int); */
}
ent = create_proc_entry("timeslice", S_IWUSR | S_IRUGO, proc_ppc64_pmc_system_root);
if (ent) {
ent->nlink = 1;
ent->proc_fops = &proc_timeslice_operations;
}
/* Create directories for the hardware counters. */
for (i = 0; i < systemcfg->processorCount; i++) {
ent = create_proc_entry("hardware", S_IRUGO | S_IWUSR,
proc_ppc64_pmc_cpu_root[i]);
if (ent) {
ent->nlink = 1;
ent->data = (void *)proc_ppc64_pmc_cpu_root[i];
ent->read_proc = (void *)proc_ppc64_pmc_hw_read;
ent->write_proc = NULL;
}
}
ent = create_proc_entry("hardware", S_IRUGO | S_IWUSR,
proc_ppc64_pmc_system_root);
if (ent) {
ent->nlink = 1;
ent->data = (void *)proc_ppc64_pmc_system_root;
ent->read_proc = (void *)proc_ppc64_pmc_hw_read;
ent->write_proc = NULL;
}
}
/* Read a page of raw data. "data" points to the start addr.
* Intended as a proc read function.
*/
static int proc_ppc64_page_read(char *page, char **start, off_t off,
int count, int *eof, void *data)
{
int len = PAGE_SIZE - off;
char *p = (char *)data;
if (len > count)
len = count;
if (len <= 0)
return 0;
/* Rely on a "hack" in fs/proc/generic.c.
* If we could return a ptr to our own data this would be
* trivial (currently *start must be either an offset, or
* point into the given page).
*/
memcpy(page, p+off, len);
*start = (char *)len;
return len;
}
/* NOTE: since paca data is always in flux the values will never be a consistant set.
* In theory it could be made consistent if we made the corresponding cpu
* copy the page for us (via an IPI). Probably not worth it.
*
*/
static void proc_ppc64_create_paca(int num, struct proc_dir_entry *paca_dir)
{
struct proc_dir_entry *ent;
struct paca_struct *lpaca = paca + num;
char buf[16];
sprintf(buf, "%02x", num);
ent = create_proc_read_entry(buf, S_IRUSR, paca_dir, proc_ppc64_page_read, lpaca);
}
/*
* Find the requested 'file' given a proc token.
*
* Inputs: void * data: proc token
* Output: int : (0, ..., +N) = CPU number.
* -1 = System.
*/
int proc_ppc64_pmc_find_file(void *data)
{
int i;
if ((unsigned long)data ==
(unsigned long) proc_ppc64_pmc_system_root) {
return(-1);
} else {
for (i = 0; i < systemcfg->processorCount; i++) {
if ((unsigned long)data ==
(unsigned long)proc_ppc64_pmc_cpu_root[i]) {
return(i);
}
}
}
/* On error, just default to a type of system. */
printk("proc_ppc64_pmc_find_file: failed to find file token.\n");
return(-1);
}
int
proc_ppc64_pmc_read(char *page, char **start, off_t off,
int count, int *eof, char *buffer)
{
int buffer_size, n;
if (count < 0) return 0;
if (buffer == NULL) {
*eof = 1;
return 0;
}
/* Check for read beyond EOF */
buffer_size = n = strlen(buffer);
if (off >= buffer_size) {
*eof = 1;
return 0;
}
if (n > (buffer_size - off)) n = buffer_size - off;
/* Never return more than was requested */
if (n > count) {
n = count;
} else {
*eof = 1;
}
memcpy(page, buffer + off, n);
*start = page;
return n;
}
int
proc_ppc64_pmc_stab_read(char *page, char **start, off_t off,
int count, int *eof, void *data)
{
int n, file;
char *buffer = NULL;
if (count < 0) return 0;
spin_lock(&proc_ppc64_lock);
/* Figure out which file is being request. */
file = proc_ppc64_pmc_find_file(data);
/* Update the counters and the text buffer representation. */
buffer = ppc64_pmc_stab(file);
/* Put the data into the requestor's buffer. */
n = proc_ppc64_pmc_read(page, start, off, count, eof, buffer);
spin_unlock(&proc_ppc64_lock);
return n;
}
int
proc_ppc64_pmc_htab_read(char *page, char **start, off_t off,
int count, int *eof, void *data)
{
int n, file;
char *buffer = NULL;
if (count < 0) return 0;
spin_lock(&proc_ppc64_lock);
/* Figure out which file is being request. */
file = proc_ppc64_pmc_find_file(data);
/* Update the counters and the text buffer representation. */
buffer = ppc64_pmc_htab(file);
/* Put the data into the requestor's buffer. */
n = proc_ppc64_pmc_read(page, start, off, count, eof, buffer);
spin_unlock(&proc_ppc64_lock);
return n;
}
static ssize_t read_profile(struct file *file, char *buf,
size_t count, loff_t *ppos)
{
unsigned long p = *ppos;
ssize_t read;
char * pnt;
unsigned int sample_step = 4;
if (p >= (perfmon_base.profile_length+1)) return 0;
if (count > (perfmon_base.profile_length+1) - p)
count = (perfmon_base.profile_length+1) - p;
read = 0;
while (p < sizeof(unsigned int) && count > 0) {
put_user(*((char *)(&sample_step)+p),buf);
buf++; p++; count--; read++;
}
pnt = (char *)(perfmon_base.profile_buffer) + p - sizeof(unsigned int);
copy_to_user(buf,(void *)pnt,count);
p += count;
read += count;
*ppos = p;
return read;
}
static ssize_t write_profile(struct file * file, const char * buf,
size_t count, loff_t *ppos)
{
return(0);
}
static ssize_t read_trace(struct file *file, char *buf,
size_t count, loff_t *ppos)
{
unsigned long p = *ppos;
char * pnt;
if (p >= (perfmon_base.trace_length)) return 0;
if (count > (perfmon_base.trace_length) - p)
count = (perfmon_base.trace_length) - p;
pnt = (char *)(perfmon_base.trace_buffer) + p;
copy_to_user(buf,(void *)pnt,count);
p += count;
*ppos = p;
return count;
}
static ssize_t write_trace(struct file * file, const char * buf,
size_t count, loff_t *ppos)
{
return(0);
}
static ssize_t read_timeslice(struct file *file, char *buf,
size_t count, loff_t *ppos)
{
unsigned long p = *ppos;
ssize_t read;
char * pnt;
if (p >= (perfmon_base.timeslice_length)) return 0;
if (count > (perfmon_base.timeslice_length) - p)
count = (perfmon_base.timeslice_length) - p;
pnt = (char *)(perfmon_base.timeslice_buffer) + p;
copy_to_user(buf,(void *)pnt,count);
*ppos = p + count;
return count;
}
static ssize_t write_timeslice(struct file * file, const char * buf,
size_t count, loff_t *ppos)
{
return(0);
}
int
proc_ppc64_pmc_hw_read(char *page, char **start, off_t off,
int count, int *eof, void *data)
{
int n, file;
char *buffer = NULL;
if (count < 0) return 0;
spin_lock(&proc_ppc64_lock);
/* Figure out which file is being request. */
file = proc_ppc64_pmc_find_file(data);
/* Update the counters and the text buffer representation. */
buffer = ppc64_pmc_hw(file);
/* Put the data into the requestor's buffer. */
n = proc_ppc64_pmc_read(page, start, off, count, eof, buffer);
spin_unlock(&proc_ppc64_lock);
return n;
}
/*
* DRENG the remainder of these functions still need work ...
*/
void pmc_proc_init(struct proc_dir_entry *iSeries_proc)
{
struct proc_dir_entry *ent = NULL;
ent = create_proc_entry("lpevents", S_IFREG|S_IRUGO, iSeries_proc);
if (!ent) return;
ent->nlink = 1;
ent->data = (void *)0;
ent->read_proc = proc_get_lpevents;
ent->write_proc = proc_reset_lpevents;
ent = create_proc_entry("titanTod", S_IFREG|S_IRUGO, iSeries_proc);
if (!ent) return;
ent->nlink = 1;
ent->data = (void *)0;
ent->size = 0;
ent->read_proc = proc_get_titanTod;
ent->write_proc = NULL;
pmc_proc_root = proc_mkdir("pmc", iSeries_proc);
if (!pmc_proc_root) return;
ent = create_proc_entry("control", S_IFREG|S_IRUSR|S_IWUSR, pmc_proc_root);
if (!ent) return;
ent->nlink = 1;
ent->data = (void *)0;
ent->read_proc = proc_pmc_get_control;
ent->write_proc = proc_pmc_set_control;
}
static int pmc_calc_metrics( char *page, char **start, off_t off, int count, int *eof, int len)
{
if ( len <= off+count)
*eof = 1;
*start = page+off;
len -= off;
if ( len > count )
len = count;
if ( len < 0 )
len = 0;
return len;
}
static char * lpEventTypes[9] = {
"Hypervisor\t\t",
"Machine Facilities\t",
"Session Manager\t",
"SPD I/O\t\t",
"Virtual Bus\t\t",
"PCI I/O\t\t",
"RIO I/O\t\t",
"Virtual Lan\t\t",
"Virtual I/O\t\t"
};
int proc_get_lpevents
(char *page, char **start, off_t off, int count, int *eof, void *data)
{
unsigned i;
int len = 0;
len += sprintf( page+len, "LpEventQueue 0\n" );
len += sprintf( page+len, " events processed:\t%lu\n",
(unsigned long)xItLpQueue.xLpIntCount );
for (i=0; i<9; ++i) {
len += sprintf( page+len, " %s %10lu\n",
lpEventTypes[i],
(unsigned long)xItLpQueue.xLpIntCountByType[i] );
}
len += sprintf( page+len, "\n events processed by processor:\n" );
for (i=0; i<systemcfg->processorCount; ++i) {
len += sprintf( page+len, " CPU%02d %10u\n",
i, paca[i].lpEvent_count );
}
return pmc_calc_metrics( page, start, off, count, eof, len );
}
int proc_reset_lpevents( struct file *file, const char *buffer, unsigned long count, void *data )
{
return count;
}
static unsigned long startTitan = 0;
static unsigned long startTb = 0;
int proc_get_titanTod
(char *page, char **start, off_t off, int count, int *eof, void *data)
{
int len = 0;
unsigned long tb0, titan_tod;
tb0 = get_tb();
titan_tod = HvCallXm_loadTod();
len += sprintf( page+len, "Titan\n" );
len += sprintf( page+len, " time base = %016lx\n", tb0 );
len += sprintf( page+len, " titan tod = %016lx\n", titan_tod );
len += sprintf( page+len, " xProcFreq = %016x\n", xIoHriProcessorVpd[0].xProcFreq );
len += sprintf( page+len, " xTimeBaseFreq = %016x\n", xIoHriProcessorVpd[0].xTimeBaseFreq );
len += sprintf( page+len, " tb_ticks_per_jiffy = %lu\n", tb_ticks_per_jiffy );
len += sprintf( page+len, " tb_ticks_per_usec = %lu\n", tb_ticks_per_usec );
if ( !startTitan ) {
startTitan = titan_tod;
startTb = tb0;
}
else {
unsigned long titan_usec = (titan_tod - startTitan) >> 12;
unsigned long tb_ticks = (tb0 - startTb);
unsigned long titan_jiffies = titan_usec / (1000000/HZ);
unsigned long titan_jiff_usec = titan_jiffies * (1000000/HZ);
unsigned long titan_jiff_rem_usec = titan_usec - titan_jiff_usec;
unsigned long tb_jiffies = tb_ticks / tb_ticks_per_jiffy;
unsigned long tb_jiff_ticks = tb_jiffies * tb_ticks_per_jiffy;
unsigned long tb_jiff_rem_ticks = tb_ticks - tb_jiff_ticks;
unsigned long tb_jiff_rem_usec = tb_jiff_rem_ticks / tb_ticks_per_usec;
unsigned long new_tb_ticks_per_jiffy = (tb_ticks * (1000000/HZ))/titan_usec;
len += sprintf( page+len, " titan elapsed = %lu uSec\n", titan_usec);
len += sprintf( page+len, " tb elapsed = %lu ticks\n", tb_ticks);
len += sprintf( page+len, " titan jiffies = %lu.%04lu \n", titan_jiffies, titan_jiff_rem_usec );
len += sprintf( page+len, " tb jiffies = %lu.%04lu\n", tb_jiffies, tb_jiff_rem_usec );
len += sprintf( page+len, " new tb_ticks_per_jiffy = %lu\n", new_tb_ticks_per_jiffy );
}
return pmc_calc_metrics( page, start, off, count, eof, len );
}
int proc_pmc_get_control
(char *page, char **start, off_t off, int count, int *eof, void *data)
{
int len = 0;
if ( proc_pmc_control_mode == PMC_CONTROL_CPI ) {
unsigned long mach_cycles = mfspr( PMC5 );
unsigned long inst_complete = mfspr( PMC4 );
unsigned long inst_dispatch = mfspr( PMC3 );
unsigned long thread_active_run = mfspr( PMC1 );
unsigned long thread_active = mfspr( PMC2 );
unsigned long cpi = 0;
unsigned long cpithou = 0;
unsigned long remain;
if ( inst_complete ) {
cpi = thread_active_run / inst_complete;
remain = thread_active_run % inst_complete;
if ( inst_complete > 1000000 )
cpithou = remain / ( inst_complete / 1000 );
else
cpithou = ( remain * 1000 ) / inst_complete;
}
len += sprintf( page+len, "PMC CPI Mode\nRaw Counts\n" );
len += sprintf( page+len, "machine cycles : %12lu\n", mach_cycles );
len += sprintf( page+len, "thread active cycles : %12lu\n\n", thread_active );
len += sprintf( page+len, "instructions completed : %12lu\n", inst_complete );
len += sprintf( page+len, "instructions dispatched : %12lu\n", inst_dispatch );
len += sprintf( page+len, "thread active run cycles : %12lu\n", thread_active_run );
len += sprintf( page+len, "thread active run cycles/instructions completed\n" );
len += sprintf( page+len, "CPI = %lu.%03lu\n", cpi, cpithou );
}
else if ( proc_pmc_control_mode == PMC_CONTROL_TLB ) {
len += sprintf( page+len, "PMC TLB Mode\n" );
len += sprintf( page+len, "I-miss count : %12lu\n", mfspr( PMC1 ) );
len += sprintf( page+len, "I-miss latency : %12lu\n", mfspr( PMC2 ) );
len += sprintf( page+len, "D-miss count : %12lu\n", mfspr( PMC3 ) );
len += sprintf( page+len, "D-miss latency : %12lu\n", mfspr( PMC4 ) );
len += sprintf( page+len, "IERAT miss count : %12lu\n", mfspr( PMC5 ) );
len += sprintf( page+len, "D-reference count : %12lu\n", mfspr( PMC6 ) );
len += sprintf( page+len, "miss PTEs searched : %12lu\n", mfspr( PMC7 ) );
len += sprintf( page+len, "miss >8 PTEs searched : %12lu\n", mfspr( PMC8 ) );
}
/* IMPLEMENT ME */
return pmc_calc_metrics( page, start, off, count, eof, len );
}
unsigned long proc_pmc_conv_int( const char *buf, unsigned count )
{
const char * p;
char b0, b1;
unsigned v, multiplier, mult, i;
unsigned long val;
multiplier = 10;
p = buf;
if ( count >= 3 ) {
b0 = buf[0];
b1 = buf[1];
if ( ( b0 == '0' ) &&
( ( b1 == 'x' ) || ( b1 == 'X' ) ) ) {
p = buf + 2;
count -= 2;
multiplier = 16;
}
}
val = 0;
for ( i=0; i<count; ++i ) {
b0 = *p++;
v = 0;
mult = multiplier;
if ( ( b0 >= '0' ) && ( b0 <= '9' ) )
v = b0 - '0';
else if ( multiplier == 16 ) {
if ( ( b0 >= 'a' ) && ( b0 <= 'f' ) )
v = b0 - 'a' + 10;
else if ( ( b0 >= 'A' ) && ( b0 <= 'F' ) )
v = b0 - 'A' + 10;
else
mult = 1;
}
else
mult = 1;
val *= mult;
val += v;
}
return val;
}
static inline void proc_pmc_stop(void)
{
/* Freeze all counters, leave everything else alone */
mtspr( MMCR0, mfspr( MMCR0 ) | 0x80000000 );
}
static inline void proc_pmc_start(void)
{
/* Unfreeze all counters, leave everything else alone */
mtspr( MMCR0, mfspr( MMCR0 ) & ~0x80000000 );
}
static inline void proc_pmc_reset(void)
{
/* Clear all the PMCs to zeros
* Assume a "stop" has already frozen the counters
* Clear all the PMCs
*/
mtspr( PMC1, 0 );
mtspr( PMC2, 0 );
mtspr( PMC3, 0 );
mtspr( PMC4, 0 );
mtspr( PMC5, 0 );
mtspr( PMC6, 0 );
mtspr( PMC7, 0 );
mtspr( PMC8, 0 );
}
static inline void proc_pmc_cpi(void)
{
/* Configure the PMC registers to count cycles and instructions */
/* so we can compute cpi */
/*
* MMCRA[30] = 1 Don't count in wait state (CTRL[31]=0)
* MMCR0[6] = 1 Freeze counters when any overflow
* MMCR0[19:25] = 0x01 PMC1 counts Thread Active Run Cycles
* MMCR0[26:31] = 0x05 PMC2 counts Thread Active Cycles
* MMCR1[0:4] = 0x07 PMC3 counts Instructions Dispatched
* MMCR1[5:9] = 0x03 PMC4 counts Instructions Completed
* MMCR1[10:14] = 0x06 PMC5 counts Machine Cycles
*
*/
proc_pmc_control_mode = PMC_CONTROL_CPI;
/* Indicate to hypervisor that we are using the PMCs */
get_paca()->xLpPacaPtr->xPMCRegsInUse = 1;
/* Freeze all counters */
mtspr( MMCR0, 0x80000000 );
mtspr( MMCR1, 0x00000000 );
/* Clear all the PMCs */
mtspr( PMC1, 0 );
mtspr( PMC2, 0 );
mtspr( PMC3, 0 );
mtspr( PMC4, 0 );
mtspr( PMC5, 0 );
mtspr( PMC6, 0 );
mtspr( PMC7, 0 );
mtspr( PMC8, 0 );
/* Freeze counters in Wait State (CTRL[31]=0) */
mtspr( MMCRA, 0x00000002 );
/* PMC3<-0x07, PMC4<-0x03, PMC5<-0x06 */
mtspr( MMCR1, 0x38cc0000 );
mb();
/* PMC1<-0x01, PMC2<-0x05
* Start all counters
*/
mtspr( MMCR0, 0x02000045 );
}
static inline void proc_pmc_tlb(void)
{
/* Configure the PMC registers to count tlb misses */
/*
* MMCR0[6] = 1 Freeze counters when any overflow
* MMCR0[19:25] = 0x55 Group count
* PMC1 counts I misses
* PMC2 counts I miss duration (latency)
* PMC3 counts D misses
* PMC4 counts D miss duration (latency)
* PMC5 counts IERAT misses
* PMC6 counts D references (including PMC7)
* PMC7 counts miss PTEs searched
* PMC8 counts miss >8 PTEs searched
*
*/
proc_pmc_control_mode = PMC_CONTROL_TLB;
/* Indicate to hypervisor that we are using the PMCs */
get_paca()->xLpPacaPtr->xPMCRegsInUse = 1;
/* Freeze all counters */
mtspr( MMCR0, 0x80000000 );
mtspr( MMCR1, 0x00000000 );
/* Clear all the PMCs */
mtspr( PMC1, 0 );
mtspr( PMC2, 0 );
mtspr( PMC3, 0 );
mtspr( PMC4, 0 );
mtspr( PMC5, 0 );
mtspr( PMC6, 0 );
mtspr( PMC7, 0 );
mtspr( PMC8, 0 );
mtspr( MMCRA, 0x00000000 );
mb();
/* PMC1<-0x55
* Start all counters
*/
mtspr( MMCR0, 0x02001540 );
}
int proc_pmc_set_control( struct file *file, const char *buffer, unsigned long count, void *data )
{
char stkbuf[10];
if (count > 9)
count = 9;
if (copy_from_user (stkbuf, buffer, count))
return -EFAULT;
stkbuf[count] = 0;
if ( ! strncmp( stkbuf, "stop", 4 ) )
proc_pmc_stop();
else if ( ! strncmp( stkbuf, "start", 5 ) )
proc_pmc_start();
else if ( ! strncmp( stkbuf, "reset", 5 ) )
proc_pmc_reset();
else if ( ! strncmp( stkbuf, "cpi", 3 ) )
proc_pmc_cpi();
else if ( ! strncmp( stkbuf, "tlb", 3 ) )
proc_pmc_tlb();
/* IMPLEMENT ME */
return count;
}
int proc_pmc_set_mmcr0( struct file *file, const char *buffer, unsigned long count, void *data )
{
unsigned long v;
v = proc_pmc_conv_int( buffer, count );
v = v & ~0x04000000; /* Don't allow interrupts for now */
if ( v & ~0x80000000 ) /* Inform hypervisor we are using PMCs */
get_paca()->xLpPacaPtr->xPMCRegsInUse = 1;
else
get_paca()->xLpPacaPtr->xPMCRegsInUse = 0;
mtspr( MMCR0, v );
return count;
}
int proc_pmc_set_mmcr1( struct file *file, const char *buffer, unsigned long count, void *data )
{
unsigned long v;
v = proc_pmc_conv_int( buffer, count );
mtspr( MMCR1, v );
return count;
}
int proc_pmc_set_mmcra( struct file *file, const char *buffer, unsigned long count, void *data )
{
unsigned long v;
v = proc_pmc_conv_int( buffer, count );
v = v & ~0x00008000; /* Don't allow interrupts for now */
mtspr( MMCRA, v );
return count;
}
int proc_pmc_set_pmc1( struct file *file, const char *buffer, unsigned long count, void *data )
{
unsigned long v;
v = proc_pmc_conv_int( buffer, count );
mtspr( PMC1, v );
return count;
}
int proc_pmc_set_pmc2( struct file *file, const char *buffer, unsigned long count, void *data )
{
unsigned long v;
v = proc_pmc_conv_int( buffer, count );
mtspr( PMC2, v );
return count;
}
int proc_pmc_set_pmc3( struct file *file, const char *buffer, unsigned long count, void *data )
{
unsigned long v;
v = proc_pmc_conv_int( buffer, count );
mtspr( PMC3, v );
return count;
}
int proc_pmc_set_pmc4( struct file *file, const char *buffer, unsigned long count, void *data )
{
unsigned long v;
v = proc_pmc_conv_int( buffer, count );
mtspr( PMC4, v );
return count;
}
int proc_pmc_set_pmc5( struct file *file, const char *buffer, unsigned long count, void *data )
{
unsigned long v;
v = proc_pmc_conv_int( buffer, count );
mtspr( PMC5, v );
return count;
}
int proc_pmc_set_pmc6( struct file *file, const char *buffer, unsigned long count, void *data )
{
unsigned long v;
v = proc_pmc_conv_int( buffer, count );
mtspr( PMC6, v );
return count;
}
int proc_pmc_set_pmc7( struct file *file, const char *buffer, unsigned long count, void *data )
{
unsigned long v;
v = proc_pmc_conv_int( buffer, count );
mtspr( PMC7, v );
return count;
}
int proc_pmc_set_pmc8( struct file *file, const char *buffer, unsigned long count, void *data )
{
unsigned long v;
v = proc_pmc_conv_int( buffer, count );
mtspr( PMC8, v );
return count;
}
static loff_t nacamap_seek( struct file *file, loff_t off, int whence)
{
loff_t new;
struct proc_dir_entry *dp;
dp = file->f_dentry->d_inode->u.generic_ip;
switch(whence) {
case 0:
new = off;
break;
case 1:
new = file->f_pos + off;
break;
case 2:
new = dp->size + off;
break;
default:
return -EINVAL;
}
if ( new < 0 || new > dp->size )
return -EINVAL;
return (file->f_pos = new);
}
static ssize_t nacamap_read( struct file *file, char *buf, size_t nbytes, loff_t *ppos)
{
unsigned pos = *ppos;
struct proc_dir_entry *dp;
dp = file->f_dentry->d_inode->u.generic_ip;
if ( pos >= dp->size )
return 0;
if ( nbytes >= dp->size )
nbytes = dp->size;
if ( pos + nbytes > dp->size )
nbytes = dp->size - pos;
copy_to_user( buf, (char *)dp->data + pos, nbytes );
*ppos = pos + nbytes;
return nbytes;
}
static int nacamap_mmap( struct file *file, struct vm_area_struct *vma )
{
struct proc_dir_entry *dp;
dp = file->f_dentry->d_inode->u.generic_ip;
vma->vm_flags |= VM_SHM | VM_LOCKED;
if ((vma->vm_end - vma->vm_start) > dp->size)
return -EINVAL;
remap_page_range( vma->vm_start, __pa(dp->data), dp->size, vma->vm_page_prot );
return 0;
}
static int proc_ppc64_smt_snooze_read(char *page, char **start, off_t off,
int count, int *eof, void *data)
{
if (naca->smt_snooze_delay)
return sprintf(page, "%lu\n", naca->smt_snooze_delay);
else
return sprintf(page, "disabled\n");
}
static int proc_ppc64_smt_snooze_write(struct file* file, const char *buffer,
unsigned long count, void *data)
{
unsigned long val;
char val_string[22];
if (!capable(CAP_SYS_ADMIN))
return -EACCES;
if (count > sizeof(val_string) - 1)
return -EINVAL;
if (copy_from_user(val_string, buffer, count))
return -EFAULT;
val_string[count] = '\0';
if (val_string[0] == '0' && (val_string[1] == '\n' || val_string[1] == '\0')) {
naca->smt_snooze_delay = 0;
return count;
}
val = simple_strtoul(val_string, NULL, 10);
if (val != 0)
naca->smt_snooze_delay = val;
else
return -EINVAL;
return count;
}
static int proc_ppc64_smt_state_read(char *page, char **start, off_t off,
int count, int *eof, void *data)
{
switch(naca->smt_state) {
case SMT_OFF:
return sprintf(page, "off\n");
break;
case SMT_ON:
return sprintf(page, "on\n");
break;
case SMT_DYNAMIC:
return sprintf(page, "dynamic\n");
break;
default:
return sprintf(page, "unknown\n");
break;
}
}
void proc_ppc64_create_smt(void)
{
struct proc_dir_entry *ent_snooze =
create_proc_entry("smt-snooze-delay", S_IRUGO | S_IWUSR,
proc_ppc64_root);
struct proc_dir_entry *ent_enabled =
create_proc_entry("smt-enabled", S_IRUGO | S_IWUSR,
proc_ppc64_root);
if (ent_snooze) {
ent_snooze->nlink = 1;
ent_snooze->data = NULL;
ent_snooze->read_proc = (void *)proc_ppc64_smt_snooze_read;
ent_snooze->write_proc = (void *)proc_ppc64_smt_snooze_write;
}
if (ent_enabled) {
ent_enabled->nlink = 1;
ent_enabled->data = NULL;
ent_enabled->read_proc = (void *)proc_ppc64_smt_state_read;
ent_enabled->write_proc = NULL;
}
}
![[BACK]](/icons/back.gif){kind=icon}
Return to proc_pmc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [Development] / linux-2.4-xfs / arch / ppc64 / kernel