Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8f51ba8e authored by Ingo Molnar's avatar Ingo Molnar
Browse files

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

Merge tag 'perf-core-for-mingo-4.20-20181008' 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:

 - Fix building the python bindings with python3, which fixes some
   problems with building with clang on Clear Linux (Eduardo Habkost)

 - Fix coverity warnings, fixing up some error paths and plugging
   some temporary small buffer leaks (Sanskriti Sharma)

 - Adopt a wrapper for strerror_r() for the same reasons as recently
   for libbpf (Steven Rostedt)

 - S390 does not support watchpoints in perf test 22', check if
   that test is supported by the arch. (Thomas Richter)

Signed-off-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parents 6364cb22 bb3dd7e7

tools/include/linux/bitops.h

+2 −5
Original line number Diff line number Diff line
@@ -3,8 +3,6 @@ 
#define _TOOLS_LINUX_BITOPS_H_



#include <asm/types.h>

#include <linux/compiler.h>



#ifndef __WORDSIZE

#define __WORDSIZE (__SIZEOF_LONG__ * 8)

#endif
@@ -12,10 +10,9 @@ 
#ifndef BITS_PER_LONG

# define BITS_PER_LONG __WORDSIZE

#endif

#include <linux/bits.h>

#include <linux/compiler.h>



#define BIT_MASK(nr)		(1UL << ((nr) % BITS_PER_LONG))

#define BIT_WORD(nr)		((nr) / BITS_PER_LONG)

#define BITS_PER_BYTE		8

#define BITS_TO_LONGS(nr)	DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))

#define BITS_TO_U64(nr)		DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(u64))

#define BITS_TO_U32(nr)		DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(u32))

tools/include/linux/bits.h

0 → 100644
+26 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

#ifndef __LINUX_BITS_H

#define __LINUX_BITS_H

#include <asm/bitsperlong.h>



#define BIT(nr)			(1UL << (nr))

#define BIT_ULL(nr)		(1ULL << (nr))

#define BIT_MASK(nr)		(1UL << ((nr) % BITS_PER_LONG))

#define BIT_WORD(nr)		((nr) / BITS_PER_LONG)

#define BIT_ULL_MASK(nr)	(1ULL << ((nr) % BITS_PER_LONG_LONG))

#define BIT_ULL_WORD(nr)	((nr) / BITS_PER_LONG_LONG)

#define BITS_PER_BYTE		8



/*

 * Create a contiguous bitmask starting at bit position @l and ending at

 * position @h. For example

 * GENMASK_ULL(39, 21) gives us the 64bit vector 0x000000ffffe00000.

 */

#define GENMASK(h, l) \

	(((~0UL) - (1UL << (l)) + 1) & (~0UL >> (BITS_PER_LONG - 1 - (h))))



#define GENMASK_ULL(h, l) \

	(((~0ULL) - (1ULL << (l)) + 1) & \

	 (~0ULL >> (BITS_PER_LONG_LONG - 1 - (h))))



#endif	/* __LINUX_BITS_H */

tools/lib/traceevent/Build

+2 −0
Original line number Diff line number Diff line
@@ -4,6 +4,8 @@ libtraceevent-y += trace-seq.o 
libtraceevent-y += parse-filter.o

libtraceevent-y += parse-utils.o

libtraceevent-y += kbuffer-parse.o

libtraceevent-y += tep_strerror.o

libtraceevent-y += event-parse-api.o



plugin_jbd2-y         += plugin_jbd2.o

plugin_hrtimer-y      += plugin_hrtimer.o

tools/lib/traceevent/event-parse-api.c

0 → 100644
+275 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: LGPL-2.1

/*

 * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>

 *

 */



#include "event-parse.h"

#include "event-parse-local.h"

#include "event-utils.h"



/**

 * tep_get_first_event - returns the first event in the events array

 * @tep: a handle to the tep_handle

 *

 * This returns pointer to the first element of the events array

 * If @tep is NULL, NULL is returned.

 */

struct tep_event_format *tep_get_first_event(struct tep_handle *tep)

{

	if (tep && tep->events)

		return tep->events[0];



	return NULL;

}



/**

 * tep_get_events_count - get the number of defined events

 * @tep: a handle to the tep_handle

 *

 * This returns number of elements in event array

 * If @tep is NULL, 0 is returned.

 */

int tep_get_events_count(struct tep_handle *tep)

{

	if(tep)

		return tep->nr_events;

	return 0;

}



/**

 * tep_set_flag - set event parser flag

 * @tep: a handle to the tep_handle

 * @flag: flag, or combination of flags to be set

 * can be any combination from enum tep_flag

 *

 * This sets a flag or mbination of flags  from enum tep_flag

  */

void tep_set_flag(struct tep_handle *tep, int flag)

{

	if(tep)

		tep->flags |= flag;

}



unsigned short __tep_data2host2(struct tep_handle *pevent, unsigned short data)

{

	unsigned short swap;



	if (!pevent || pevent->host_bigendian == pevent->file_bigendian)

		return data;



	swap = ((data & 0xffULL) << 8) |

		((data & (0xffULL << 8)) >> 8);



	return swap;

}



unsigned int __tep_data2host4(struct tep_handle *pevent, unsigned int data)

{

	unsigned int swap;



	if (!pevent || pevent->host_bigendian == pevent->file_bigendian)

		return data;



	swap = ((data & 0xffULL) << 24) |

		((data & (0xffULL << 8)) << 8) |

		((data & (0xffULL << 16)) >> 8) |

		((data & (0xffULL << 24)) >> 24);



	return swap;

}



unsigned long long

__tep_data2host8(struct tep_handle *pevent, unsigned long long data)

{

	unsigned long long swap;



	if (!pevent || pevent->host_bigendian == pevent->file_bigendian)

		return data;



	swap = ((data & 0xffULL) << 56) |

		((data & (0xffULL << 8)) << 40) |

		((data & (0xffULL << 16)) << 24) |

		((data & (0xffULL << 24)) << 8) |

		((data & (0xffULL << 32)) >> 8) |

		((data & (0xffULL << 40)) >> 24) |

		((data & (0xffULL << 48)) >> 40) |

		((data & (0xffULL << 56)) >> 56);



	return swap;

}



/**

 * tep_get_header_page_size - get size of the header page

 * @pevent: a handle to the tep_handle

 *

 * This returns size of the header page

 * If @pevent is NULL, 0 is returned.

 */

int tep_get_header_page_size(struct tep_handle *pevent)

{

	if(pevent)

		return pevent->header_page_size_size;

	return 0;

}



/**

 * tep_get_cpus - get the number of CPUs

 * @pevent: a handle to the tep_handle

 *

 * This returns the number of CPUs

 * If @pevent is NULL, 0 is returned.

 */

int tep_get_cpus(struct tep_handle *pevent)

{

	if(pevent)

		return pevent->cpus;

	return 0;

}



/**

 * tep_set_cpus - set the number of CPUs

 * @pevent: a handle to the tep_handle

 *

 * This sets the number of CPUs

 */

void tep_set_cpus(struct tep_handle *pevent, int cpus)

{

	if(pevent)

		pevent->cpus = cpus;

}



/**

 * tep_get_long_size - get the size of a long integer on the current machine

 * @pevent: a handle to the tep_handle

 *

 * This returns the size of a long integer on the current machine

 * If @pevent is NULL, 0 is returned.

 */

int tep_get_long_size(struct tep_handle *pevent)

{

	if(pevent)

		return pevent->long_size;

	return 0;

}



/**

 * tep_set_long_size - set the size of a long integer on the current machine

 * @pevent: a handle to the tep_handle

 * @size: size, in bytes, of a long integer

 *

 * This sets the size of a long integer on the current machine

 */

void tep_set_long_size(struct tep_handle *pevent, int long_size)

{

	if(pevent)

		pevent->long_size = long_size;

}



/**

 * tep_get_page_size - get the size of a memory page on the current machine

 * @pevent: a handle to the tep_handle

 *

 * This returns the size of a memory page on the current machine

 * If @pevent is NULL, 0 is returned.

 */

int tep_get_page_size(struct tep_handle *pevent)

{

	if(pevent)

		return pevent->page_size;

	return 0;

}



/**

 * tep_set_page_size - set the size of a memory page on the current machine

 * @pevent: a handle to the tep_handle

 * @_page_size: size of a memory page, in bytes

 *

 * This sets the size of a memory page on the current machine

 */

void tep_set_page_size(struct tep_handle *pevent, int _page_size)

{

	if(pevent)

		pevent->page_size = _page_size;

}



/**

 * tep_is_file_bigendian - get if the file is in big endian order

 * @pevent: a handle to the tep_handle

 *

 * This returns if the file is in big endian order

 * If @pevent is NULL, 0 is returned.

 */

int tep_is_file_bigendian(struct tep_handle *pevent)

{

	if(pevent)

		return pevent->file_bigendian;

	return 0;

}



/**

 * tep_set_file_bigendian - set if the file is in big endian order

 * @pevent: a handle to the tep_handle

 * @endian: non zero, if the file is in big endian order

 *

 * This sets if the file is in big endian order

 */

void tep_set_file_bigendian(struct tep_handle *pevent, enum tep_endian endian)

{

	if(pevent)

		pevent->file_bigendian = endian;

}



/**

 * tep_is_host_bigendian - get if the order of the current host is big endian

 * @pevent: a handle to the tep_handle

 *

 * This gets if the order of the current host is big endian

 * If @pevent is NULL, 0 is returned.

 */

int tep_is_host_bigendian(struct tep_handle *pevent)

{

	if(pevent)

		return pevent->host_bigendian;

	return 0;

}



/**

 * tep_set_host_bigendian - set the order of the local host

 * @pevent: a handle to the tep_handle

 * @endian: non zero, if the local host has big endian order

 *

 * This sets the order of the local host

 */

void tep_set_host_bigendian(struct tep_handle *pevent, enum tep_endian endian)

{

	if(pevent)

		pevent->host_bigendian = endian;

}



/**

 * tep_is_latency_format - get if the latency output format is configured

 * @pevent: a handle to the tep_handle

 *

 * This gets if the latency output format is configured

 * If @pevent is NULL, 0 is returned.

 */

int tep_is_latency_format(struct tep_handle *pevent)

{

	if(pevent)

		return pevent->latency_format;

	return 0;

}



/**

 * tep_set_latency_format - set the latency output format

 * @pevent: a handle to the tep_handle

 * @lat: non zero for latency output format

 *

 * This sets the latency output format

  */

void tep_set_latency_format(struct tep_handle *pevent, int lat)

{

	if(pevent)

		pevent->latency_format = lat;

}

tools/lib/traceevent/event-parse-local.h

0 → 100644
+92 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: LGPL-2.1

/*

 * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>

 *

 */



#ifndef _PARSE_EVENTS_INT_H

#define _PARSE_EVENTS_INT_H



struct cmdline;

struct cmdline_list;

struct func_map;

struct func_list;

struct event_handler;

struct func_resolver;



struct tep_handle {

	int ref_count;



	int header_page_ts_offset;

	int header_page_ts_size;

	int header_page_size_offset;

	int header_page_size_size;

	int header_page_data_offset;

	int header_page_data_size;

	int header_page_overwrite;



	enum tep_endian file_bigendian;

	enum tep_endian host_bigendian;



	int latency_format;



	int old_format;



	int cpus;

	int long_size;

	int page_size;



	struct cmdline *cmdlines;

	struct cmdline_list *cmdlist;

	int cmdline_count;



	struct func_map *func_map;

	struct func_resolver *func_resolver;

	struct func_list *funclist;

	unsigned int func_count;



	struct printk_map *printk_map;

	struct printk_list *printklist;

	unsigned int printk_count;





	struct tep_event_format **events;

	int nr_events;

	struct tep_event_format **sort_events;

	enum tep_event_sort_type last_type;



	int type_offset;

	int type_size;



	int pid_offset;

	int pid_size;



	int pc_offset;

	int pc_size;



	int flags_offset;

	int flags_size;



	int ld_offset;

	int ld_size;



	int print_raw;



	int test_filters;



	int flags;



	struct tep_format_field *bprint_ip_field;

	struct tep_format_field *bprint_fmt_field;

	struct tep_format_field *bprint_buf_field;



	struct event_handler *handlers;

	struct tep_function_handler *func_handlers;



	/* cache */

	struct tep_event_format *last_event;



	char *trace_clock;

};



#endif /* _PARSE_EVENTS_INT_H */