Merge tag 'perf-core-for-mingo-20161123' of...

#include <stdint.h>

#include <limits.h>

#include <linux/string.h>

#include <linux/time64.h>

#include <netinet/in.h>

#include "event-parse.h"

}

/**

 * pevent_data_pid - parse the PID from raw data

 * pevent_data_pid - parse the PID from record

 * @pevent: a handle to the pevent

 * @rec: the record to parse

 *

 * This returns the PID from a raw data.

 * This returns the PID from a record.

 */

int pevent_data_pid(struct pevent *pevent, struct pevent_record *rec)

{

	return parse_common_pid(pevent, rec->data);

}

/**

 * pevent_data_prempt_count - parse the preempt count from the record

 * @pevent: a handle to the pevent

 * @rec: the record to parse

 *

 * This returns the preempt count from a record.

 */

int pevent_data_prempt_count(struct pevent *pevent, struct pevent_record *rec)

{

	return parse_common_pc(pevent, rec->data);

}

/**

 * pevent_data_flags - parse the latency flags from the record

 * @pevent: a handle to the pevent

 * @rec: the record to parse

 *

 * This returns the latency flags from a record.

 *

 *  Use trace_flag_type enum for the flags (see event-parse.h).

 */

int pevent_data_flags(struct pevent *pevent, struct pevent_record *rec)

{

	return parse_common_flags(pevent, rec->data);

}

/**

 * pevent_data_comm_from_pid - return the command line from PID

 * @pevent: a handle to the pevent

	use_usec_format = is_timestamp_in_us(pevent->trace_clock,

							use_trace_clock);

	if (use_usec_format) {

		secs = record->ts / NSECS_PER_SEC;

		nsecs = record->ts - secs * NSECS_PER_SEC;

		secs = record->ts / NSEC_PER_SEC;

		nsecs = record->ts - secs * NSEC_PER_SEC;

	}

	if (pevent->latency_format) {

			usecs = nsecs;

			p = 9;

		} else {

			usecs = (nsecs + 500) / NSECS_PER_USEC;

			usecs = (nsecs + 500) / NSEC_PER_USEC;

			/* To avoid usecs larger than 1 sec */

			if (usecs >= 1000000) {

				usecs -= 1000000;

			if (usecs >= USEC_PER_SEC) {

				usecs -= USEC_PER_SEC;

				secs++;

			}

			p = 6;

#define PEVENT_PLUGIN_OPTIONS_NAME MAKE_STR(PEVENT_PLUGIN_OPTIONS)

#define PEVENT_PLUGIN_ALIAS_NAME MAKE_STR(PEVENT_PLUGIN_ALIAS)

#define NSECS_PER_SEC		1000000000ULL

#define NSECS_PER_USEC		1000ULL

enum format_flags {

	FIELD_IS_ARRAY		= 1,

	FIELD_IS_POINTER	= 2,

int pevent_data_type(struct pevent *pevent, struct pevent_record *rec);

struct event_format *pevent_data_event_from_type(struct pevent *pevent, int type);

int pevent_data_pid(struct pevent *pevent, struct pevent_record *rec);

int pevent_data_prempt_count(struct pevent *pevent, struct pevent_record *rec);

int pevent_data_flags(struct pevent *pevent, struct pevent_record *rec);

const char *pevent_data_comm_from_pid(struct pevent *pevent, int pid);

struct cmdline;

struct cmdline *pevent_data_pid_from_comm(struct pevent *pevent, const char *comm,

--show-all::

	Show all captured HITM lines, with no regard to HITM % 0.0005 limit.

-f::

--force::

	Don't do ownership validation.

-d::

--display::

	Siwtch to HITM type (rmt, lcl) to display and sort on. Total HITMs as default.

C2C RECORD

----------

The perf c2c record command setup options related to HITM cacheline analysis

SYNOPSIS

--------

[verse]

'perf sched' {record|latency|map|replay|script}

'perf sched' {record|latency|map|replay|script|timehist}

DESCRIPTION

-----------

There are five variants of perf sched:

There are several variants of 'perf sched':

  'perf sched record <command>' to record the scheduling events

  of an arbitrary workload.

  are running on a CPU. A '*' denotes the CPU that had the event, and

  a dot signals an idle CPU.

  'perf sched timehist' provides an analysis of scheduling events.

    Example usage:

        perf sched record -- sleep 1

        perf sched timehist

   By default it shows the individual schedule events, including the wait

   time (time between sched-out and next sched-in events for the task), the

   task scheduling delay (time between wakeup and actually running) and run

   time for the task:

                time    cpu  task name             wait time  sch delay   run time

                             [tid/pid]                (msec)     (msec)     (msec)

      -------------- ------  --------------------  ---------  ---------  ---------

        79371.874569 [0011]  gcc[31949]                0.014      0.000      1.148

        79371.874591 [0010]  gcc[31951]                0.000      0.000      0.024

        79371.874603 [0010]  migration/10[59]          3.350      0.004      0.011

        79371.874604 [0011]  <idle>                    1.148      0.000      0.035

        79371.874723 [0005]  <idle>                    0.016      0.000      1.383

        79371.874746 [0005]  gcc[31949]                0.153      0.078      0.022

    ...

   Times are in msec.usec.

OPTIONS

-------

-i::

--color-pids::

	Highlight the given pids.

OPTIONS for 'perf sched timehist'

---------------------------------

-k::

--vmlinux=<file>::

    vmlinux pathname

--kallsyms=<file>::

    kallsyms pathname

-g::

--no-call-graph::

	Do not display call chains if present.

--max-stack::

	Maximum number of functions to display in backtrace, default 5.

-s::

--summary::

    Show only a summary of scheduling by thread with min, max, and average

    run times (in sec) and relative stddev.

-S::

--with-summary::

    Show all scheduling events followed by a summary by thread with min,

    max, and average run times (in sec) and relative stddev.

--symfs=<directory>::

    Look for files with symbols relative to this directory.

-V::

--cpu-visual::

	Show visual aid for sched switches by CPU: 'i' marks idle time,

	's' are scheduler events.

-w::

--wakeups::

	Show wakeup events.

SEE ALSO

--------

linkperf:perf-record[1]

static struct ins arm__instructions[] = {

	{ .name = "add",	.ops = &mov_ops,  },

	{ .name = "addl",	.ops = &mov_ops,  },

	{ .name = "addq",	.ops = &mov_ops,  },

	{ .name = "addw",	.ops = &mov_ops,  },

	{ .name = "and",	.ops = &mov_ops,  },

	{ .name = "b",		.ops = &jump_ops, }, // might also be a call

	{ .name = "bcc",	.ops = &jump_ops, },

	{ .name = "bcs",	.ops = &jump_ops, },

	{ .name = "beq",	.ops = &jump_ops, },

	{ .name = "bge",	.ops = &jump_ops, },

	{ .name = "bgt",	.ops = &jump_ops, },

	{ .name = "bhi",	.ops = &jump_ops, },

	{ .name = "bl",		.ops = &call_ops, },

	{ .name = "bls",	.ops = &jump_ops, },

	{ .name = "blt",	.ops = &jump_ops, },

	{ .name = "blx",	.ops = &call_ops, },

	{ .name = "bne",	.ops = &jump_ops, },

	{ .name = "bts",	.ops = &mov_ops,  },

	{ .name = "call",	.ops = &call_ops, },

	{ .name = "callq",	.ops = &call_ops, },

	{ .name = "cmp",	.ops = &mov_ops,  },

	{ .name = "cmpb",	.ops = &mov_ops,  },

	{ .name = "cmpl",	.ops = &mov_ops,  },

	{ .name = "cmpq",	.ops = &mov_ops,  },

	{ .name = "cmpw",	.ops = &mov_ops,  },

	{ .name = "cmpxch",	.ops = &mov_ops,  },

	{ .name = "dec",	.ops = &dec_ops,  },

	{ .name = "decl",	.ops = &dec_ops,  },

	{ .name = "imul",	.ops = &mov_ops,  },

	{ .name = "inc",	.ops = &dec_ops,  },

	{ .name = "incl",	.ops = &dec_ops,  },

	{ .name = "ja",		.ops = &jump_ops, },

	{ .name = "jae",	.ops = &jump_ops, },

	{ .name = "jb",		.ops = &jump_ops, },

	{ .name = "jbe",	.ops = &jump_ops, },

	{ .name = "jc",		.ops = &jump_ops, },

	{ .name = "jcxz",	.ops = &jump_ops, },

	{ .name = "je",		.ops = &jump_ops, },

	{ .name = "jecxz",	.ops = &jump_ops, },

	{ .name = "jg",		.ops = &jump_ops, },

	{ .name = "jge",	.ops = &jump_ops, },

	{ .name = "jl",		.ops = &jump_ops, },

	{ .name = "jle",	.ops = &jump_ops, },

	{ .name = "jmp",	.ops = &jump_ops, },

	{ .name = "jmpq",	.ops = &jump_ops, },

	{ .name = "jna",	.ops = &jump_ops, },

	{ .name = "jnae",	.ops = &jump_ops, },

	{ .name = "jnb",	.ops = &jump_ops, },

	{ .name = "jnbe",	.ops = &jump_ops, },

	{ .name = "jnc",	.ops = &jump_ops, },

	{ .name = "jne",	.ops = &jump_ops, },

	{ .name = "jng",	.ops = &jump_ops, },

	{ .name = "jnge",	.ops = &jump_ops, },

	{ .name = "jnl",	.ops = &jump_ops, },

	{ .name = "jnle",	.ops = &jump_ops, },

	{ .name = "jno",	.ops = &jump_ops, },

	{ .name = "jnp",	.ops = &jump_ops, },

	{ .name = "jns",	.ops = &jump_ops, },

	{ .name = "jnz",	.ops = &jump_ops, },

	{ .name = "jo",		.ops = &jump_ops, },

	{ .name = "jp",		.ops = &jump_ops, },

	{ .name = "jpe",	.ops = &jump_ops, },

	{ .name = "jpo",	.ops = &jump_ops, },

	{ .name = "jrcxz",	.ops = &jump_ops, },

	{ .name = "js",		.ops = &jump_ops, },

	{ .name = "jz",		.ops = &jump_ops, },

	{ .name = "lea",	.ops = &mov_ops,  },

	{ .name = "lock",	.ops = &lock_ops, },

	{ .name = "mov",	.ops = &mov_ops,  },

	{ .name = "movb",	.ops = &mov_ops,  },

	{ .name = "movdqa",	.ops = &mov_ops,  },

	{ .name = "movl",	.ops = &mov_ops,  },

	{ .name = "movq",	.ops = &mov_ops,  },

	{ .name = "movslq",	.ops = &mov_ops,  },

	{ .name = "movzbl",	.ops = &mov_ops,  },

	{ .name = "movzwl",	.ops = &mov_ops,  },

	{ .name = "nop",	.ops = &nop_ops,  },

	{ .name = "nopl",	.ops = &nop_ops,  },

	{ .name = "nopw",	.ops = &nop_ops,  },

	{ .name = "or",		.ops = &mov_ops,  },

	{ .name = "orl",	.ops = &mov_ops,  },

	{ .name = "test",	.ops = &mov_ops,  },

	{ .name = "testb",	.ops = &mov_ops,  },

	{ .name = "testl",	.ops = &mov_ops,  },

	{ .name = "xadd",	.ops = &mov_ops,  },

	{ .name = "xbeginl",	.ops = &jump_ops, },

	{ .name = "xbeginq",	.ops = &jump_ops, },

	{ .name = "retq",	.ops = &ret_ops,  },

};