Commit 3bd76175 authored by Ingo Molnar's avatar Ingo Molnar
Browse files

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

Merge tag 'perf-core-for-mingo' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux

 into perf/core

Pull perf/core improvements and fixes from Arnaldo Carvalho de Melo:

User visible changes:

  - Use PERF_RECORD_SWITCH when available in intel-pt, instead of
    "sched:sched_switch" events, enabling an unprivileged user to trace
    multi-threaded or multi-process workloads. (Adrian Hunter)

  - Always use non inlined file name for 'srcfile' sort key. (Andi Kleen)

  - Quieten failed to read counter message, helps in systems without
    backend-stalled-cycles. (Andi Kleen)

Infrastructure changes:

  - Add a 'perf test' entry for decoding of new x86 instructions. (Adrian Hunter)

  - Add new instructions (sha, clflushopt, clwb, pcommit, rdpkru, wrpkru, xsavec,
    xsaves, xrstors) to the x86 instruction decoder. (Adrian Hunter)

  - Add a build test to warn when source code drifts happen for the
    instruction decoder files in the kernel and in tools/perf. (Adrian Hunter)

  - Copy linux/filter.h to tools/include. (He Kuang)

  - Support function __get_dynamic_array_len in libtraceevent. (He Kuanguuu)

  - Tracing path finding/mounting/error reporting refactorings. (Jiri Olsa)

  - Store CPU socket and core IDs in perf.data. (Kan Liang)

  - Reorganize add/del probe insertion routines in 'perf probe'. (Namhyung Kim, Wang Nan)

Signed-off-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parents 21adf76e cf2f33a4

arch/x86/lib/x86-opcode-map.txt

+19 −5
Original line number Diff line number Diff line
@@ -353,8 +353,12 @@ AVXcode: 1 
17: vmovhps Mq,Vq (v1) | vmovhpd Mq,Vq (66),(v1)

18: Grp16 (1A)

19:

1a: BNDCL Ev,Gv | BNDCU Ev,Gv | BNDMOV Gv,Ev | BNDLDX Gv,Ev,Gv

1b: BNDCN Ev,Gv | BNDMOV Ev,Gv | BNDMK Gv,Ev | BNDSTX Ev,GV,Gv

# Intel SDM opcode map does not list MPX instructions. For now using Gv for

# bnd registers and Ev for everything else is OK because the instruction

# decoder does not use the information except as an indication that there is

# a ModR/M byte.

1a: BNDCL Gv,Ev (F3) | BNDCU Gv,Ev (F2) | BNDMOV Gv,Ev (66) | BNDLDX Gv,Ev

1b: BNDCN Gv,Ev (F2) | BNDMOV Ev,Gv (66) | BNDMK Gv,Ev (F3) | BNDSTX Ev,Gv

1c:

1d:

1e:
@@ -732,6 +736,12 @@ bd: vfnmadd231ss/d Vx,Hx,Wx (66),(v),(v1) 
be: vfnmsub231ps/d Vx,Hx,Wx (66),(v)

bf: vfnmsub231ss/d Vx,Hx,Wx (66),(v),(v1)

# 0x0f 0x38 0xc0-0xff

c8: sha1nexte Vdq,Wdq

c9: sha1msg1 Vdq,Wdq

ca: sha1msg2 Vdq,Wdq

cb: sha256rnds2 Vdq,Wdq

cc: sha256msg1 Vdq,Wdq

cd: sha256msg2 Vdq,Wdq

db: VAESIMC Vdq,Wdq (66),(v1)

dc: VAESENC Vdq,Hdq,Wdq (66),(v1)

dd: VAESENCLAST Vdq,Hdq,Wdq (66),(v1)
@@ -790,6 +800,7 @@ AVXcode: 3 
61: vpcmpestri Vdq,Wdq,Ib (66),(v1)

62: vpcmpistrm Vdq,Wdq,Ib (66),(v1)

63: vpcmpistri Vdq,Wdq,Ib (66),(v1)

cc: sha1rnds4 Vdq,Wdq,Ib

df: VAESKEYGEN Vdq,Wdq,Ib (66),(v1)

f0: RORX Gy,Ey,Ib (F2),(v)

EndTable
@@ -874,7 +885,7 @@ GrpTable: Grp7 
2: LGDT Ms | XGETBV (000),(11B) | XSETBV (001),(11B) | VMFUNC (100),(11B) | XEND (101)(11B) | XTEST (110)(11B)

3: LIDT Ms

4: SMSW Mw/Rv

5:

5: rdpkru (110),(11B) | wrpkru (111),(11B)

6: LMSW Ew

7: INVLPG Mb | SWAPGS (o64),(000),(11B) | RDTSCP (001),(11B)

EndTable
@@ -888,6 +899,9 @@ EndTable 


GrpTable: Grp9

1: CMPXCHG8B/16B Mq/Mdq

3: xrstors

4: xsavec

5: xsaves

6: VMPTRLD Mq | VMCLEAR Mq (66) | VMXON Mq (F3) | RDRAND Rv (11B)

7: VMPTRST Mq | VMPTRST Mq (F3) | RDSEED Rv (11B)

EndTable
@@ -932,8 +946,8 @@ GrpTable: Grp15 
3: vstmxcsr Md (v1) | WRGSBASE Ry (F3),(11B)

4: XSAVE

5: XRSTOR | lfence (11B)

6: XSAVEOPT | mfence (11B)

7: clflush | sfence (11B)

6: XSAVEOPT | clwb (66) | mfence (11B)

7: clflush | clflushopt (66) | sfence (11B) | pcommit (66),(11B)

EndTable



GrpTable: Grp16

tools/include/linux/filter.h

0 → 100644
+231 −0
Original line number Diff line number Diff line 
/*

 * Linux Socket Filter Data Structures

 */

#ifndef __TOOLS_LINUX_FILTER_H

#define __TOOLS_LINUX_FILTER_H



#include <linux/bpf.h>



/* ArgX, context and stack frame pointer register positions. Note,

 * Arg1, Arg2, Arg3, etc are used as argument mappings of function

 * calls in BPF_CALL instruction.

 */

#define BPF_REG_ARG1	BPF_REG_1

#define BPF_REG_ARG2	BPF_REG_2

#define BPF_REG_ARG3	BPF_REG_3

#define BPF_REG_ARG4	BPF_REG_4

#define BPF_REG_ARG5	BPF_REG_5

#define BPF_REG_CTX	BPF_REG_6

#define BPF_REG_FP	BPF_REG_10



/* Additional register mappings for converted user programs. */

#define BPF_REG_A	BPF_REG_0

#define BPF_REG_X	BPF_REG_7

#define BPF_REG_TMP	BPF_REG_8



/* BPF program can access up to 512 bytes of stack space. */

#define MAX_BPF_STACK	512



/* Helper macros for filter block array initializers. */



/* ALU ops on registers, bpf_add|sub|...: dst_reg += src_reg */



#define BPF_ALU64_REG(OP, DST, SRC)				\

	((struct bpf_insn) {					\

		.code  = BPF_ALU64 | BPF_OP(OP) | BPF_X,	\

		.dst_reg = DST,					\

		.src_reg = SRC,					\

		.off   = 0,					\

		.imm   = 0 })



#define BPF_ALU32_REG(OP, DST, SRC)				\

	((struct bpf_insn) {					\

		.code  = BPF_ALU | BPF_OP(OP) | BPF_X,		\

		.dst_reg = DST,					\

		.src_reg = SRC,					\

		.off   = 0,					\

		.imm   = 0 })



/* ALU ops on immediates, bpf_add|sub|...: dst_reg += imm32 */



#define BPF_ALU64_IMM(OP, DST, IMM)				\

	((struct bpf_insn) {					\

		.code  = BPF_ALU64 | BPF_OP(OP) | BPF_K,	\

		.dst_reg = DST,					\

		.src_reg = 0,					\

		.off   = 0,					\

		.imm   = IMM })



#define BPF_ALU32_IMM(OP, DST, IMM)				\

	((struct bpf_insn) {					\

		.code  = BPF_ALU | BPF_OP(OP) | BPF_K,		\

		.dst_reg = DST,					\

		.src_reg = 0,					\

		.off   = 0,					\

		.imm   = IMM })



/* Endianess conversion, cpu_to_{l,b}e(), {l,b}e_to_cpu() */



#define BPF_ENDIAN(TYPE, DST, LEN)				\

	((struct bpf_insn) {					\

		.code  = BPF_ALU | BPF_END | BPF_SRC(TYPE),	\

		.dst_reg = DST,					\

		.src_reg = 0,					\

		.off   = 0,					\

		.imm   = LEN })



/* Short form of mov, dst_reg = src_reg */



#define BPF_MOV64_REG(DST, SRC)					\

	((struct bpf_insn) {					\

		.code  = BPF_ALU64 | BPF_MOV | BPF_X,		\

		.dst_reg = DST,					\

		.src_reg = SRC,					\

		.off   = 0,					\

		.imm   = 0 })



#define BPF_MOV32_REG(DST, SRC)					\

	((struct bpf_insn) {					\

		.code  = BPF_ALU | BPF_MOV | BPF_X,		\

		.dst_reg = DST,					\

		.src_reg = SRC,					\

		.off   = 0,					\

		.imm   = 0 })



/* Short form of mov, dst_reg = imm32 */



#define BPF_MOV64_IMM(DST, IMM)					\

	((struct bpf_insn) {					\

		.code  = BPF_ALU64 | BPF_MOV | BPF_K,		\

		.dst_reg = DST,					\

		.src_reg = 0,					\

		.off   = 0,					\

		.imm   = IMM })



#define BPF_MOV32_IMM(DST, IMM)					\

	((struct bpf_insn) {					\

		.code  = BPF_ALU | BPF_MOV | BPF_K,		\

		.dst_reg = DST,					\

		.src_reg = 0,					\

		.off   = 0,					\

		.imm   = IMM })



/* Short form of mov based on type,  BPF_X: dst_reg = src_reg, BPF_K: dst_reg = imm32 */



#define BPF_MOV64_RAW(TYPE, DST, SRC, IMM)			\

	((struct bpf_insn) {					\

		.code  = BPF_ALU64 | BPF_MOV | BPF_SRC(TYPE),	\

		.dst_reg = DST,					\

		.src_reg = SRC,					\

		.off   = 0,					\

		.imm   = IMM })



#define BPF_MOV32_RAW(TYPE, DST, SRC, IMM)			\

	((struct bpf_insn) {					\

		.code  = BPF_ALU | BPF_MOV | BPF_SRC(TYPE),	\

		.dst_reg = DST,					\

		.src_reg = SRC,					\

		.off   = 0,					\

		.imm   = IMM })



/* Direct packet access, R0 = *(uint *) (skb->data + imm32) */



#define BPF_LD_ABS(SIZE, IMM)					\

	((struct bpf_insn) {					\

		.code  = BPF_LD | BPF_SIZE(SIZE) | BPF_ABS,	\

		.dst_reg = 0,					\

		.src_reg = 0,					\

		.off   = 0,					\

		.imm   = IMM })



/* Indirect packet access, R0 = *(uint *) (skb->data + src_reg + imm32) */



#define BPF_LD_IND(SIZE, SRC, IMM)				\

	((struct bpf_insn) {					\

		.code  = BPF_LD | BPF_SIZE(SIZE) | BPF_IND,	\

		.dst_reg = 0,					\

		.src_reg = SRC,					\

		.off   = 0,					\

		.imm   = IMM })



/* Memory load, dst_reg = *(uint *) (src_reg + off16) */



#define BPF_LDX_MEM(SIZE, DST, SRC, OFF)			\

	((struct bpf_insn) {					\

		.code  = BPF_LDX | BPF_SIZE(SIZE) | BPF_MEM,	\

		.dst_reg = DST,					\

		.src_reg = SRC,					\

		.off   = OFF,					\

		.imm   = 0 })



/* Memory store, *(uint *) (dst_reg + off16) = src_reg */



#define BPF_STX_MEM(SIZE, DST, SRC, OFF)			\

	((struct bpf_insn) {					\

		.code  = BPF_STX | BPF_SIZE(SIZE) | BPF_MEM,	\

		.dst_reg = DST,					\

		.src_reg = SRC,					\

		.off   = OFF,					\

		.imm   = 0 })



/* Memory store, *(uint *) (dst_reg + off16) = imm32 */



#define BPF_ST_MEM(SIZE, DST, OFF, IMM)				\

	((struct bpf_insn) {					\

		.code  = BPF_ST | BPF_SIZE(SIZE) | BPF_MEM,	\

		.dst_reg = DST,					\

		.src_reg = 0,					\

		.off   = OFF,					\

		.imm   = IMM })



/* Conditional jumps against registers, if (dst_reg 'op' src_reg) goto pc + off16 */



#define BPF_JMP_REG(OP, DST, SRC, OFF)				\

	((struct bpf_insn) {					\

		.code  = BPF_JMP | BPF_OP(OP) | BPF_X,		\

		.dst_reg = DST,					\

		.src_reg = SRC,					\

		.off   = OFF,					\

		.imm   = 0 })



/* Conditional jumps against immediates, if (dst_reg 'op' imm32) goto pc + off16 */



#define BPF_JMP_IMM(OP, DST, IMM, OFF)				\

	((struct bpf_insn) {					\

		.code  = BPF_JMP | BPF_OP(OP) | BPF_K,		\

		.dst_reg = DST,					\

		.src_reg = 0,					\

		.off   = OFF,					\

		.imm   = IMM })



/* Function call */



#define BPF_EMIT_CALL(FUNC)					\

	((struct bpf_insn) {					\

		.code  = BPF_JMP | BPF_CALL,			\

		.dst_reg = 0,					\

		.src_reg = 0,					\

		.off   = 0,					\

		.imm   = ((FUNC) - BPF_FUNC_unspec) })



/* Raw code statement block */



#define BPF_RAW_INSN(CODE, DST, SRC, OFF, IMM)			\

	((struct bpf_insn) {					\

		.code  = CODE,					\

		.dst_reg = DST,					\

		.src_reg = SRC,					\

		.off   = OFF,					\

		.imm   = IMM })



/* Program exit */



#define BPF_EXIT_INSN()						\

	((struct bpf_insn) {					\

		.code  = BPF_JMP | BPF_EXIT,			\

		.dst_reg = 0,					\

		.src_reg = 0,					\

		.off   = 0,					\

		.imm   = 0 })



#endif /* __TOOLS_LINUX_FILTER_H */

tools/lib/api/fs/Build

+1 −0
Original line number Diff line number Diff line 
libapi-y += fs.o

libapi-y += tracing_path.o

libapi-y += debugfs.o

libapi-y += findfs.o

libapi-y += tracefs.o

tools/lib/api/fs/debugfs.c

+0 −52
Original line number Diff line number Diff line
@@ -75,55 +75,3 @@ char *debugfs_mount(const char *mountpoint) 
out:

	return debugfs_mountpoint;

}
 


int debugfs__strerror_open(int err, char *buf, size_t size, const char *filename)

{

	char sbuf[128];



	switch (err) {

	case ENOENT:

		if (debugfs_found) {

			snprintf(buf, size,

				 "Error:\tFile %s/%s not found.\n"

				 "Hint:\tPerhaps this kernel misses some CONFIG_ setting to enable this feature?.\n",

				 debugfs_mountpoint, filename);

			break;

		}

		snprintf(buf, size, "%s",

			 "Error:\tUnable to find debugfs\n"

			 "Hint:\tWas your kernel compiled with debugfs support?\n"

			 "Hint:\tIs the debugfs filesystem mounted?\n"

			 "Hint:\tTry 'sudo mount -t debugfs nodev /sys/kernel/debug'");

		break;

	case EACCES: {

		const char *mountpoint = debugfs_mountpoint;



		if (!access(debugfs_mountpoint, R_OK) && strncmp(filename, "tracing/", 8) == 0) {

			const char *tracefs_mntpoint = tracefs_find_mountpoint();



			if (tracefs_mntpoint)

				mountpoint = tracefs_mntpoint;

		}



		snprintf(buf, size,

			 "Error:\tNo permissions to read %s/%s\n"

			 "Hint:\tTry 'sudo mount -o remount,mode=755 %s'\n",

			 debugfs_mountpoint, filename, mountpoint);

	}

		break;

	default:

		snprintf(buf, size, "%s", strerror_r(err, sbuf, sizeof(sbuf)));

		break;

	}



	return 0;

}



int debugfs__strerror_open_tp(int err, char *buf, size_t size, const char *sys, const char *name)

{

	char path[PATH_MAX];



	snprintf(path, PATH_MAX, "tracing/events/%s/%s", sys, name ?: "*");



	return debugfs__strerror_open(err, buf, size, path);

}

tools/lib/api/fs/fs.c

+107 −10
Original line number Diff line number Diff line 
/* TODO merge/factor in debugfs.c here */



#include <ctype.h>

#include <errno.h>

#include <stdbool.h>
@@ -11,10 +9,30 @@ 
#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <sys/mount.h>



#include "debugfs.h"

#include "fs.h"



#define _STR(x) #x

#define STR(x) _STR(x)



#ifndef SYSFS_MAGIC

#define SYSFS_MAGIC            0x62656572

#endif



#ifndef PROC_SUPER_MAGIC

#define PROC_SUPER_MAGIC       0x9fa0

#endif



#ifndef DEBUGFS_MAGIC

#define DEBUGFS_MAGIC          0x64626720

#endif



#ifndef TRACEFS_MAGIC

#define TRACEFS_MAGIC          0x74726163

#endif



static const char * const sysfs__fs_known_mountpoints[] = {

	"/sys",

	0,
@@ -25,6 +43,29 @@ static const char * const procfs__known_mountpoints[] = { 
	0,

};



#ifndef DEBUGFS_DEFAULT_PATH

#define DEBUGFS_DEFAULT_PATH "/sys/kernel/debug"

#endif



static const char * const debugfs__known_mountpoints[] = {

	DEBUGFS_DEFAULT_PATH,

	"/debug",

	0,

};





#ifndef TRACEFS_DEFAULT_PATH

#define TRACEFS_DEFAULT_PATH "/sys/kernel/tracing"

#endif



static const char * const tracefs__known_mountpoints[] = {

	TRACEFS_DEFAULT_PATH,

	"/sys/kernel/debug/tracing",

	"/tracing",

	"/trace",

	0,

};



struct fs {

	const char		*name;

	const char * const	*mounts;
@@ -36,8 +77,14 @@ struct fs { 
enum {

	FS__SYSFS   = 0,

	FS__PROCFS  = 1,

	FS__DEBUGFS = 2,

	FS__TRACEFS = 3,

};



#ifndef TRACEFS_MAGIC

#define TRACEFS_MAGIC 0x74726163

#endif



static struct fs fs__entries[] = {

	[FS__SYSFS] = {

		.name	= "sysfs",
@@ -49,6 +96,16 @@ static struct fs fs__entries[] = { 
		.mounts	= procfs__known_mountpoints,

		.magic	= PROC_SUPER_MAGIC,

	},

	[FS__DEBUGFS] = {

		.name	= "debugfs",

		.mounts	= debugfs__known_mountpoints,

		.magic	= DEBUGFS_MAGIC,

	},

	[FS__TRACEFS] = {

		.name	= "tracefs",

		.mounts	= tracefs__known_mountpoints,

		.magic	= TRACEFS_MAGIC,

	},

};



static bool fs__read_mounts(struct fs *fs)
@@ -159,14 +216,54 @@ static const char *fs__mountpoint(int idx) 
	return fs__get_mountpoint(fs);

}



#define FS__MOUNTPOINT(name, idx)	\

static const char *mount_overload(struct fs *fs)

{

	size_t name_len = strlen(fs->name);

	/* "PERF_" + name + "_ENVIRONMENT" + '\0' */

	char upper_name[5 + name_len + 12 + 1];



	snprintf(upper_name, name_len, "PERF_%s_ENVIRONMENT", fs->name);

	mem_toupper(upper_name, name_len);



	return getenv(upper_name) ?: *fs->mounts;

}



static const char *fs__mount(int idx)

{

	struct fs *fs = &fs__entries[idx];

	const char *mountpoint;



	if (fs__mountpoint(idx))

		return (const char *)fs->path;



	mountpoint = mount_overload(fs);



	if (mount(NULL, mountpoint, fs->name, 0, NULL) < 0)

		return NULL;



	return fs__check_mounts(fs) ? fs->path : NULL;

}



#define FS(name, idx)				\

const char *name##__mountpoint(void)		\

{						\

	return fs__mountpoint(idx);		\

}						\

						\

const char *name##__mount(void)			\

{						\

	return fs__mount(idx);			\

}						\

						\

bool name##__configured(void)			\

{						\

	return name##__mountpoint() != NULL;	\

}



FS__MOUNTPOINT(sysfs,  FS__SYSFS);

FS__MOUNTPOINT(procfs, FS__PROCFS);

FS(sysfs,   FS__SYSFS);

FS(procfs,  FS__PROCFS);

FS(debugfs, FS__DEBUGFS);

FS(tracefs, FS__TRACEFS);



int filename__read_int(const char *filename, int *value)

{

CRA Git | Maintained and supported by SUSTech CRA and CCSE