arch: powerpc: Remove oprofile

# SPDX-License-Identifier: GPL-2.0

ccflags-$(CONFIG_PPC64)	:= $(NO_MINIMAL_TOC)

obj-$(CONFIG_OPROFILE) += oprofile.o

DRIVER_OBJS := $(addprefix ../../../drivers/oprofile/, \

		oprof.o cpu_buffer.o buffer_sync.o \

		event_buffer.o oprofile_files.o \

		oprofilefs.o oprofile_stats.o \

		timer_int.o )

oprofile-y := $(DRIVER_OBJS) common.o backtrace.o

oprofile-$(CONFIG_OPROFILE_CELL) += op_model_cell.o \

		cell/spu_profiler.o cell/vma_map.o \

		cell/spu_task_sync.o

oprofile-$(CONFIG_PPC_BOOK3S_64) += op_model_power4.o op_model_pa6t.o

oprofile-$(CONFIG_FSL_EMB_PERFMON) += op_model_fsl_emb.o

oprofile-$(CONFIG_PPC_BOOK3S_32) += op_model_7450.o

// SPDX-License-Identifier: GPL-2.0-or-later

/**

 * Copyright (C) 2005 Brian Rogan <bcr6@cornell.edu>, IBM

 *

**/

#include <linux/time.h>

#include <linux/oprofile.h>

#include <linux/sched.h>

#include <asm/processor.h>

#include <linux/uaccess.h>

#include <linux/compat.h>

#include <asm/oprofile_impl.h>

#define STACK_SP(STACK)		*(STACK)

#define STACK_LR64(STACK)	*((unsigned long *)(STACK) + 2)

#define STACK_LR32(STACK)	*((unsigned int *)(STACK) + 1)

#ifdef CONFIG_PPC64

#define STACK_LR(STACK)		STACK_LR64(STACK)

#else

#define STACK_LR(STACK)		STACK_LR32(STACK)

#endif

static unsigned int user_getsp32(unsigned int sp, int is_first)

{

	unsigned int stack_frame[2];

	void __user *p = compat_ptr(sp);

	/*

	 * The most likely reason for this is that we returned -EFAULT,

	 * which means that we've done all that we can do from

	 * interrupt context.

	 */

	if (copy_from_user_nofault(stack_frame, (void __user *)p,

			sizeof(stack_frame)))

		return 0;

	if (!is_first)

		oprofile_add_trace(STACK_LR32(stack_frame));

	/*

	 * We do not enforce increasing stack addresses here because

	 * we may transition to a different stack, eg a signal handler.

	 */

	return STACK_SP(stack_frame);

}

#ifdef CONFIG_PPC64

static unsigned long user_getsp64(unsigned long sp, int is_first)

{

	unsigned long stack_frame[3];

	if (copy_from_user_nofault(stack_frame, (void __user *)sp,

			sizeof(stack_frame)))

		return 0;

	if (!is_first)

		oprofile_add_trace(STACK_LR64(stack_frame));

	return STACK_SP(stack_frame);

}

#endif

static unsigned long kernel_getsp(unsigned long sp, int is_first)

{

	unsigned long *stack_frame = (unsigned long *)sp;

	if (!validate_sp(sp, current, STACK_FRAME_OVERHEAD))

		return 0;

	if (!is_first)

		oprofile_add_trace(STACK_LR(stack_frame));

	/*

	 * We do not enforce increasing stack addresses here because

	 * we might be transitioning from an interrupt stack to a kernel

	 * stack. validate_sp() is designed to understand this, so just

	 * use it.

	 */

	return STACK_SP(stack_frame);

}

void op_powerpc_backtrace(struct pt_regs * const regs, unsigned int depth)

{

	unsigned long sp = regs->gpr[1];

	int first_frame = 1;

	/* We ditch the top stackframe so need to loop through an extra time */

	depth += 1;

	if (!user_mode(regs)) {

		while (depth--) {

			sp = kernel_getsp(sp, first_frame);

			if (!sp)

				break;

			first_frame = 0;

		}

	} else {

#ifdef CONFIG_PPC64

		if (!is_32bit_task()) {

			while (depth--) {

				sp = user_getsp64(sp, first_frame);

				if (!sp)

					break;

				first_frame = 0;

			}

			return;

		}

#endif

		while (depth--) {

			sp = user_getsp32(sp, first_frame);

			if (!sp)

				break;

			first_frame = 0;

		}

	}

}

/* SPDX-License-Identifier: GPL-2.0-or-later */

 /*

 * Cell Broadband Engine OProfile Support

 *

 * (C) Copyright IBM Corporation 2006

 *

 * Author: Maynard Johnson <maynardj@us.ibm.com>

 */

#ifndef PR_UTIL_H

#define PR_UTIL_H

#include <linux/cpumask.h>

#include <linux/oprofile.h>

#include <asm/cell-pmu.h>

#include <asm/cell-regs.h>

#include <asm/spu.h>

/* Defines used for sync_start */

#define SKIP_GENERIC_SYNC 0

#define SYNC_START_ERROR -1

#define DO_GENERIC_SYNC 1

#define SPUS_PER_NODE   8

#define DEFAULT_TIMER_EXPIRE  (HZ / 10)

extern struct delayed_work spu_work;

extern int spu_prof_running;

#define TRACE_ARRAY_SIZE 1024

extern spinlock_t oprof_spu_smpl_arry_lck;

struct spu_overlay_info {	/* map of sections within an SPU overlay */

	unsigned int vma;	/* SPU virtual memory address from elf */

	unsigned int size;	/* size of section from elf */

	unsigned int offset;	/* offset of section into elf file */

	unsigned int buf;

};

struct vma_to_fileoffset_map {	/* map of sections within an SPU program */

	struct vma_to_fileoffset_map *next;	/* list pointer */

	unsigned int vma;	/* SPU virtual memory address from elf */

	unsigned int size;	/* size of section from elf */

	unsigned int offset;	/* offset of section into elf file */

	unsigned int guard_ptr;

	unsigned int guard_val;

        /*

	 * The guard pointer is an entry in the _ovly_buf_table,

	 * computed using ovly.buf as the index into the table.  Since

	 * ovly.buf values begin at '1' to reference the first (or 0th)

	 * entry in the _ovly_buf_table, the computation subtracts 1

	 * from ovly.buf.

	 * The guard value is stored in the _ovly_buf_table entry and

	 * is an index (starting at 1) back to the _ovly_table entry

	 * that is pointing at this _ovly_buf_table entry.  So, for

	 * example, for an overlay scenario with one overlay segment

	 * and two overlay sections:

	 *      - Section 1 points to the first entry of the

	 *        _ovly_buf_table, which contains a guard value

	 *        of '1', referencing the first (index=0) entry of

	 *        _ovly_table.

	 *      - Section 2 points to the second entry of the

	 *        _ovly_buf_table, which contains a guard value

	 *        of '2', referencing the second (index=1) entry of

	 *        _ovly_table.

	 */

};

struct spu_buffer {

	int last_guard_val;

	int ctx_sw_seen;

	unsigned long *buff;

	unsigned int head, tail;

};

/* The three functions below are for maintaining and accessing

 * the vma-to-fileoffset map.

 */

struct vma_to_fileoffset_map *create_vma_map(const struct spu *spu,

					     unsigned long objectid);

unsigned int vma_map_lookup(struct vma_to_fileoffset_map *map,

			    unsigned int vma, const struct spu *aSpu,

			    int *grd_val);

void vma_map_free(struct vma_to_fileoffset_map *map);

/*

 * Entry point for SPU profiling.

 * cycles_reset is the SPU_CYCLES count value specified by the user.

 */

int start_spu_profiling_cycles(unsigned int cycles_reset);

void start_spu_profiling_events(void);

void stop_spu_profiling_cycles(void);

void stop_spu_profiling_events(void);

/* add the necessary profiling hooks */

int spu_sync_start(void);

/* remove the hooks */

int spu_sync_stop(void);

/* Record SPU program counter samples to the oprofile event buffer. */

void spu_sync_buffer(int spu_num, unsigned int *samples,

		     int num_samples);

void set_spu_profiling_frequency(unsigned int freq_khz, unsigned int cycles_reset);

#endif	  /* PR_UTIL_H */

// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * Cell Broadband Engine OProfile Support

 *

 * (C) Copyright IBM Corporation 2006

 *

 * Authors: Maynard Johnson <maynardj@us.ibm.com>

 *	    Carl Love <carll@us.ibm.com>

 */

#include <linux/hrtimer.h>

#include <linux/smp.h>

#include <linux/slab.h>

#include <asm/cell-pmu.h>

#include <asm/time.h>

#include "pr_util.h"

#define SCALE_SHIFT 14

static u32 *samples;

/* spu_prof_running is a flag used to indicate if spu profiling is enabled

 * or not.  It is set by the routines start_spu_profiling_cycles() and

 * start_spu_profiling_events().  The flag is cleared by the routines

 * stop_spu_profiling_cycles() and stop_spu_profiling_events().  These

 * routines are called via global_start() and global_stop() which are called in

 * op_powerpc_start() and op_powerpc_stop().  These routines are called once

 * per system as a result of the user starting/stopping oprofile.  Hence, only

 * one CPU per user at a time will be changing  the value of spu_prof_running.

 * In general, OProfile does not protect against multiple users trying to run

 * OProfile at a time.

 */

int spu_prof_running;

static unsigned int profiling_interval;

#define NUM_SPU_BITS_TRBUF 16

#define SPUS_PER_TB_ENTRY   4

#define SPU_PC_MASK	     0xFFFF

DEFINE_SPINLOCK(oprof_spu_smpl_arry_lck);

static unsigned long oprof_spu_smpl_arry_lck_flags;

void set_spu_profiling_frequency(unsigned int freq_khz, unsigned int cycles_reset)

{

	unsigned long ns_per_cyc;

	if (!freq_khz)

		freq_khz = ppc_proc_freq/1000;

	/* To calculate a timeout in nanoseconds, the basic

	 * formula is ns = cycles_reset * (NSEC_PER_SEC / cpu frequency).

	 * To avoid floating point math, we use the scale math

	 * technique as described in linux/jiffies.h.  We use

	 * a scale factor of SCALE_SHIFT, which provides 4 decimal places

	 * of precision.  This is close enough for the purpose at hand.

	 *

	 * The value of the timeout should be small enough that the hw

	 * trace buffer will not get more than about 1/3 full for the

	 * maximum user specified (the LFSR value) hw sampling frequency.

	 * This is to ensure the trace buffer will never fill even if the

	 * kernel thread scheduling varies under a heavy system load.

	 */

	ns_per_cyc = (USEC_PER_SEC << SCALE_SHIFT)/freq_khz;

	profiling_interval = (ns_per_cyc * cycles_reset) >> SCALE_SHIFT;

}

/*

 * Extract SPU PC from trace buffer entry

 */

static void spu_pc_extract(int cpu, int entry)

{

	/* the trace buffer is 128 bits */

	u64 trace_buffer[2];

	u64 spu_mask;

	int spu;

	spu_mask = SPU_PC_MASK;

	/* Each SPU PC is 16 bits; hence, four spus in each of

	 * the two 64-bit buffer entries that make up the

	 * 128-bit trace_buffer entry.	Process two 64-bit values

	 * simultaneously.

	 * trace[0] SPU PC contents are: 0 1 2 3

	 * trace[1] SPU PC contents are: 4 5 6 7

	 */

	cbe_read_trace_buffer(cpu, trace_buffer);

	for (spu = SPUS_PER_TB_ENTRY-1; spu >= 0; spu--) {

		/* spu PC trace entry is upper 16 bits of the

		 * 18 bit SPU program counter

		 */

		samples[spu * TRACE_ARRAY_SIZE + entry]

			= (spu_mask & trace_buffer[0]) << 2;

		samples[(spu + SPUS_PER_TB_ENTRY) * TRACE_ARRAY_SIZE + entry]

			= (spu_mask & trace_buffer[1]) << 2;

		trace_buffer[0] = trace_buffer[0] >> NUM_SPU_BITS_TRBUF;

		trace_buffer[1] = trace_buffer[1] >> NUM_SPU_BITS_TRBUF;

	}

}

static int cell_spu_pc_collection(int cpu)

{

	u32 trace_addr;

	int entry;

	/* process the collected SPU PC for the node */

	entry = 0;

	trace_addr = cbe_read_pm(cpu, trace_address);

	while (!(trace_addr & CBE_PM_TRACE_BUF_EMPTY)) {

		/* there is data in the trace buffer to process */

		spu_pc_extract(cpu, entry);

		entry++;

		if (entry >= TRACE_ARRAY_SIZE)

			/* spu_samples is full */

			break;

		trace_addr = cbe_read_pm(cpu, trace_address);

	}

	return entry;

}

static enum hrtimer_restart profile_spus(struct hrtimer *timer)

{

	ktime_t kt;

	int cpu, node, k, num_samples, spu_num;

	if (!spu_prof_running)

		goto stop;

	for_each_online_cpu(cpu) {

		if (cbe_get_hw_thread_id(cpu))

			continue;

		node = cbe_cpu_to_node(cpu);

		/* There should only be one kernel thread at a time processing

		 * the samples.	 In the very unlikely case that the processing

		 * is taking a very long time and multiple kernel threads are

		 * started to process the samples.  Make sure only one kernel

		 * thread is working on the samples array at a time.  The

		 * sample array must be loaded and then processed for a given

		 * cpu.	 The sample array is not per cpu.

		 */

		spin_lock_irqsave(&oprof_spu_smpl_arry_lck,

				  oprof_spu_smpl_arry_lck_flags);

		num_samples = cell_spu_pc_collection(cpu);

		if (num_samples == 0) {

			spin_unlock_irqrestore(&oprof_spu_smpl_arry_lck,

					       oprof_spu_smpl_arry_lck_flags);

			continue;

		}

		for (k = 0; k < SPUS_PER_NODE; k++) {

			spu_num = k + (node * SPUS_PER_NODE);

			spu_sync_buffer(spu_num,

					samples + (k * TRACE_ARRAY_SIZE),

					num_samples);

		}

		spin_unlock_irqrestore(&oprof_spu_smpl_arry_lck,

				       oprof_spu_smpl_arry_lck_flags);

	}

	smp_wmb();	/* insure spu event buffer updates are written */

			/* don't want events intermingled... */

	kt = profiling_interval;

	if (!spu_prof_running)

		goto stop;

	hrtimer_forward(timer, timer->base->get_time(), kt);

	return HRTIMER_RESTART;

 stop:

	printk(KERN_INFO "SPU_PROF: spu-prof timer ending\n");

	return HRTIMER_NORESTART;

}

static struct hrtimer timer;

/*

 * Entry point for SPU cycle profiling.

 * NOTE:  SPU profiling is done system-wide, not per-CPU.

 *

 * cycles_reset is the count value specified by the user when

 * setting up OProfile to count SPU_CYCLES.

 */

int start_spu_profiling_cycles(unsigned int cycles_reset)

{

	ktime_t kt;

	pr_debug("timer resolution: %lu\n", TICK_NSEC);

	kt = profiling_interval;

	hrtimer_init(&timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

	hrtimer_set_expires(&timer, kt);

	timer.function = profile_spus;

	/* Allocate arrays for collecting SPU PC samples */

	samples = kcalloc(SPUS_PER_NODE * TRACE_ARRAY_SIZE, sizeof(u32),

			  GFP_KERNEL);

	if (!samples)

		return -ENOMEM;

	spu_prof_running = 1;

	hrtimer_start(&timer, kt, HRTIMER_MODE_REL);

	schedule_delayed_work(&spu_work, DEFAULT_TIMER_EXPIRE);

	return 0;

}

/*

 * Entry point for SPU event profiling.

 * NOTE:  SPU profiling is done system-wide, not per-CPU.

 *

 * cycles_reset is the count value specified by the user when

 * setting up OProfile to count SPU_CYCLES.

 */

void start_spu_profiling_events(void)

{

	spu_prof_running = 1;

	schedule_delayed_work(&spu_work, DEFAULT_TIMER_EXPIRE);

	return;

}

void stop_spu_profiling_cycles(void)

{

	spu_prof_running = 0;

	hrtimer_cancel(&timer);

	kfree(samples);

	pr_debug("SPU_PROF: stop_spu_profiling_cycles issued\n");

}

void stop_spu_profiling_events(void)

{

	spu_prof_running = 0;

}