[lttng-ust.git] / liblttng-ust / lttng-context-perf-counters.c

/*
 * lttng-context-perf-counters.c
 *
 * LTTng UST performance monitoring counters (perf-counters) integration.
 *
 * Copyright (C) 2009-2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; only
 * version 2.1 of the License.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <linux/perf_event.h>
#include <lttng/ust-events.h>
#include <lttng/ust-tracer.h>
#include <lttng/ringbuffer-config.h>
#include <urcu/system.h>
#include <urcu/arch.h>
#include <urcu/rculist.h>
#include <helper.h>
#include <urcu/ref.h>
#include <usterr-signal-safe.h>
#include <signal.h>
#include "lttng-tracer-core.h"

/*
 * We use a global perf counter key and iterate on per-thread RCU lists
 * of fields in the fast path, even though this is not strictly speaking
 * what would provide the best fast-path complexity, to ensure teardown
 * of sessions vs thread exit is handled racelessly.
 *
 * Updates and traversals of thread_list are protected by UST lock.
 * Updates to rcu_field_list are protected by UST lock.
 */

struct lttng_perf_counter_thread_field {
	struct lttng_perf_counter_field *field;	/* Back reference */
	struct perf_event_mmap_page *pc;
	struct cds_list_head thread_field_node;	/* Per-field list of thread fields (node) */
	struct cds_list_head rcu_field_node;	/* RCU per-thread list of fields (node) */
};

struct lttng_perf_counter_thread {
	struct cds_list_head rcu_field_list;	/* RCU per-thread list of fields */
};

struct lttng_perf_counter_field {
	struct perf_event_attr attr;
	struct cds_list_head thread_field_list;	/* Per-field list of thread fields */
};

static pthread_key_t perf_counter_key;

static
size_t perf_counter_get_size(size_t offset)
{
	size_t size = 0;

	size += lib_ring_buffer_align(offset, lttng_alignof(uint64_t));
	size += sizeof(uint64_t);
	return size;
}

#if defined(__x86_64__) || defined(__i386__)

static
uint64_t rdpmc(unsigned int counter)
{
	unsigned int low, high;

	asm volatile("rdpmc" : "=a" (low), "=d" (high) : "c" (counter));

	return low | ((uint64_t) high) << 32;
}

#else /* defined(__x86_64__) || defined(__i386__) */

#error "Perf event counters are only supported on x86 so far."

#endif /* #else defined(__x86_64__) || defined(__i386__) */

static
uint64_t read_perf_counter(struct perf_event_mmap_page *pc)
{
	uint32_t seq, idx;
	uint64_t count;

	if (caa_unlikely(!pc))
		return 0;

	do {
		seq = CMM_LOAD_SHARED(pc->lock);
		cmm_barrier();

		idx = pc->index;
		if (idx)
			count = pc->offset + rdpmc(idx - 1);
		else
			count = 0;

		cmm_barrier();
	} while (CMM_LOAD_SHARED(pc->lock) != seq);

	return count;
}

static
int sys_perf_event_open(struct perf_event_attr *attr,
		pid_t pid, int cpu, int group_fd,
		unsigned long flags)
{
	return syscall(SYS_perf_event_open, attr, pid, cpu,
			group_fd, flags);
}

static
struct perf_event_mmap_page *setup_perf(struct perf_event_attr *attr)
{
	void *perf_addr;
	int fd;

	fd = sys_perf_event_open(attr, 0, -1, -1, 0);
	if (fd < 0)
		return NULL;

	perf_addr = mmap(NULL, sizeof(struct perf_event_mmap_page),
			PROT_READ, MAP_SHARED, fd, 0);
	if (perf_addr == MAP_FAILED)
		return NULL;
	close(fd);
	return perf_addr;
}

static
void unmap_perf_page(struct perf_event_mmap_page *pc)
{
	int ret;

	if (!pc)
		return;
	ret = munmap(pc, sizeof(struct perf_event_mmap_page));
	if (ret < 0) {
		PERROR("Error in munmap");
		abort();
	}
}

static
struct lttng_perf_counter_thread *alloc_perf_counter_thread(void)
{
	struct lttng_perf_counter_thread *perf_thread;
	sigset_t newmask, oldmask;
	int ret;

	ret = sigfillset(&newmask);
	if (ret)
		abort();
	ret = pthread_sigmask(SIG_BLOCK, &newmask, &oldmask);
	if (ret)
		abort();
	/* Check again with signals disabled */
	perf_thread = pthread_getspecific(perf_counter_key);
	if (perf_thread)
		goto skip;
	perf_thread = zmalloc(sizeof(*perf_thread));
	if (!perf_thread)
		abort();
	CDS_INIT_LIST_HEAD(&perf_thread->rcu_field_list);
	ret = pthread_setspecific(perf_counter_key, perf_thread);
	if (ret)
		abort();
skip:
	ret = pthread_sigmask(SIG_SETMASK, &oldmask, NULL);
	if (ret)
		abort();
	return perf_thread;
}

static
struct lttng_perf_counter_thread_field *
	add_thread_field(struct lttng_perf_counter_field *perf_field,
		struct lttng_perf_counter_thread *perf_thread)
{
	struct lttng_perf_counter_thread_field *thread_field;
	sigset_t newmask, oldmask;
	int ret;

	ret = sigfillset(&newmask);
	if (ret)
		abort();
	ret = pthread_sigmask(SIG_BLOCK, &newmask, &oldmask);
	if (ret)
		abort();
	/* Check again with signals disabled */
	cds_list_for_each_entry_rcu(thread_field, &perf_thread->rcu_field_list,
			rcu_field_node) {
		if (thread_field->field == perf_field)
			goto skip;
	}
	thread_field = zmalloc(sizeof(*thread_field));
	if (!thread_field)
		abort();
	thread_field->field = perf_field;
	thread_field->pc = setup_perf(&perf_field->attr);
	/* Note: thread_field->pc can be NULL if setup_perf() fails. */
	ust_lock_nocheck();
	cds_list_add_rcu(&thread_field->rcu_field_node,
			&perf_thread->rcu_field_list);
	cds_list_add(&thread_field->thread_field_node,
			&perf_field->thread_field_list);
	ust_unlock();
skip:
	ret = pthread_sigmask(SIG_SETMASK, &oldmask, NULL);
	if (ret)
		abort();
	return thread_field;
}

static
struct lttng_perf_counter_thread_field *
		get_thread_field(struct lttng_perf_counter_field *field)
{
	struct lttng_perf_counter_thread *perf_thread;
	struct lttng_perf_counter_thread_field *thread_field;

	perf_thread = pthread_getspecific(perf_counter_key);
	if (!perf_thread)
		perf_thread = alloc_perf_counter_thread();
	cds_list_for_each_entry_rcu(thread_field, &perf_thread->rcu_field_list,
			rcu_field_node) {
		if (thread_field->field == field)
			return thread_field;
	}
	/* perf_counter_thread_field not found, need to add one */
	return add_thread_field(field, perf_thread);
}

static
uint64_t wrapper_perf_counter_read(struct lttng_ctx_field *field)
{
	struct lttng_perf_counter_field *perf_field;
	struct lttng_perf_counter_thread_field *perf_thread_field;

	perf_field = field->u.perf_counter;
	perf_thread_field = get_thread_field(perf_field);
	return read_perf_counter(perf_thread_field->pc);
}

static
void perf_counter_record(struct lttng_ctx_field *field,
		 struct lttng_ust_lib_ring_buffer_ctx *ctx,
		 struct lttng_channel *chan)
{
	uint64_t value;

	value = wrapper_perf_counter_read(field);
	lib_ring_buffer_align_ctx(ctx, lttng_alignof(value));
	chan->ops->event_write(ctx, &value, sizeof(value));
}

static
void perf_counter_get_value(struct lttng_ctx_field *field,
		union lttng_ctx_value *value)
{
	uint64_t v;

	v = wrapper_perf_counter_read(field);
	value->s64 = v;
}

/* Called with UST lock held */
static
void lttng_destroy_perf_thread_field(
		struct lttng_perf_counter_thread_field *thread_field)
{
	unmap_perf_page(thread_field->pc);
	cds_list_del_rcu(&thread_field->rcu_field_node);
	cds_list_del(&thread_field->thread_field_node);
	free(thread_field);
}

static
void lttng_destroy_perf_thread_key(void *_key)
{
	struct lttng_perf_counter_thread *perf_thread = _key;
	struct lttng_perf_counter_thread_field *pos, *p;

	ust_lock_nocheck();
	cds_list_for_each_entry_safe(pos, p, &perf_thread->rcu_field_list,
			rcu_field_node)
		lttng_destroy_perf_thread_field(pos);
	ust_unlock();
	free(perf_thread);
}

/* Called with UST lock held */
static
void lttng_destroy_perf_counter_field(struct lttng_ctx_field *field)
{
	struct lttng_perf_counter_field *perf_field;
	struct lttng_perf_counter_thread_field *pos, *p;

	free((char *) field->event_field.name);
	perf_field = field->u.perf_counter;
	/*
	 * This put is performed when no threads can concurrently
	 * perform a "get" concurrently, thanks to urcu-bp grace
	 * period.
	 */
	cds_list_for_each_entry_safe(pos, p, &perf_field->thread_field_list,
			thread_field_node)
		lttng_destroy_perf_thread_field(pos);
	free(perf_field);
}

/* Called with UST lock held */
int lttng_add_perf_counter_to_ctx(uint32_t type,
				uint64_t config,
				const char *name,
				struct lttng_ctx **ctx)
{
	struct lttng_ctx_field *field;
	struct lttng_perf_counter_field *perf_field;
	struct perf_event_mmap_page *tmp_pc;
	char *name_alloc;
	int ret;

	name_alloc = strdup(name);
	if (!name_alloc) {
		ret = -ENOMEM;
		goto name_alloc_error;
	}
	perf_field = zmalloc(sizeof(*perf_field));
	if (!perf_field) {
		ret = -ENOMEM;
		goto perf_field_alloc_error;
	}
	field = lttng_append_context(ctx);
	if (!field) {
		ret = -ENOMEM;
		goto append_context_error;
	}
	if (lttng_find_context(*ctx, name_alloc)) {
		ret = -EEXIST;
		goto find_error;
	}

	field->destroy = lttng_destroy_perf_counter_field;

	field->event_field.name = name_alloc;
	field->event_field.type.atype = atype_integer;
	field->event_field.type.u.basic.integer.size =
			sizeof(uint64_t) * CHAR_BIT;
	field->event_field.type.u.basic.integer.alignment =
			lttng_alignof(uint64_t) * CHAR_BIT;
	field->event_field.type.u.basic.integer.signedness =
			lttng_is_signed_type(uint64_t);
	field->event_field.type.u.basic.integer.reverse_byte_order = 0;
	field->event_field.type.u.basic.integer.base = 10;
	field->event_field.type.u.basic.integer.encoding = lttng_encode_none;
	field->get_size = perf_counter_get_size;
	field->record = perf_counter_record;
	field->get_value = perf_counter_get_value;

	perf_field->attr.type = type;
	perf_field->attr.config = config;
	perf_field->attr.exclude_kernel = 1;
	CDS_INIT_LIST_HEAD(&perf_field->thread_field_list);
	field->u.perf_counter = perf_field;

	/* Ensure that this perf counter can be used in this process. */
	tmp_pc = setup_perf(&perf_field->attr);
	if (!tmp_pc) {
		ret = -ENODEV;
		goto setup_error;
	}
	unmap_perf_page(tmp_pc);

	/*
	 * Contexts can only be added before tracing is started, so we
	 * don't have to synchronize against concurrent threads using
	 * the field here.
	 */

	return 0;

setup_error:
find_error:
	lttng_remove_context_field(ctx, field);
append_context_error:
	free(perf_field);
perf_field_alloc_error:
	free(name_alloc);
name_alloc_error:
	return ret;
}

int lttng_perf_counter_init(void)
{
	int ret;

	ret = pthread_key_create(&perf_counter_key,
			lttng_destroy_perf_thread_key);
	if (ret)
		ret = -ret;
	return ret;
}

void lttng_perf_counter_exit(void)
{
	int ret;

	ret = pthread_key_delete(perf_counter_key);
	if (ret) {
		errno = ret;
		PERROR("Error in pthread_key_delete");
	}
}
Commit	Line	Data
d58d1454 MD	1	/*
	2	* lttng-context-perf-counters.c
	3	*
	4	* LTTng UST performance monitoring counters (perf-counters) integration.
	5	*
	6	* Copyright (C) 2009-2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	7	*
	8	* This library is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License as published by the Free Software Foundation; only
	11	* version 2.1 of the License.
	12	*
	13	* This library is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* Lesser General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU Lesser General Public
	19	* License along with this library; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	21	*/
	22
	23	#include <sys/types.h>
	24	#include <unistd.h>
	25	#include <string.h>
	26	#include <stdlib.h>
	27	#include <stdio.h>
	28	#include <sys/mman.h>
	29	#include <sys/syscall.h>
	30	#include <linux/perf_event.h>
	31	#include <lttng/ust-events.h>
	32	#include <lttng/ust-tracer.h>
	33	#include <lttng/ringbuffer-config.h>
	34	#include <urcu/system.h>
	35	#include <urcu/arch.h>
	36	#include <urcu/rculist.h>
	37	#include <helper.h>
	38	#include <urcu/ref.h>
	39	#include <usterr-signal-safe.h>
	40	#include <signal.h>
	41	#include "lttng-tracer-core.h"
	42
	43	/*
	44	* We use a global perf counter key and iterate on per-thread RCU lists
	45	* of fields in the fast path, even though this is not strictly speaking
	46	* what would provide the best fast-path complexity, to ensure teardown
	47	* of sessions vs thread exit is handled racelessly.
	48	*
	49	* Updates and traversals of thread_list are protected by UST lock.
	50	* Updates to rcu_field_list are protected by UST lock.
	51	*/
	52
	53	struct lttng_perf_counter_thread_field {
	54	struct lttng_perf_counter_field field; / Back reference */
	55	struct perf_event_mmap_page *pc;
	56	struct cds_list_head thread_field_node; /* Per-field list of thread fields (node) */
	57	struct cds_list_head rcu_field_node; /* RCU per-thread list of fields (node) */
	58	};
	59
	60	struct lttng_perf_counter_thread {
	61	struct cds_list_head rcu_field_list; /* RCU per-thread list of fields */
	62	};
	63
	64	struct lttng_perf_counter_field {
65	struct perf_event_attr attr;
66	struct cds_list_head thread_field_list; /* Per-field list of thread fields */
67	};
68
69	static pthread_key_t perf_counter_key;
70
71	static
72	size_t perf_counter_get_size(size_t offset)
73	{
74	size_t size = 0;
75
76	size += lib_ring_buffer_align(offset, lttng_alignof(uint64_t));
77	size += sizeof(uint64_t);
78	return size;
79	}
80
81	#if defined(__x86_64__) \|\| defined(__i386__)
82
83	static
84	uint64_t rdpmc(unsigned int counter)
85	{
86	unsigned int low, high;
87
88	asm volatile("rdpmc" : "=a" (low), "=d" (high) : "c" (counter));
89
90	return low \| ((uint64_t) high) << 32;
91	}
92
93	#else /* defined(__x86_64__) \|\| defined(__i386__) */
94
95	#error "Perf event counters are only supported on x86 so far."
96
97	#endif /* #else defined(__x86_64__) \|\| defined(__i386__) */
98
99	static
100	uint64_t read_perf_counter(struct perf_event_mmap_page *pc)
101	{
102	uint32_t seq, idx;
103	uint64_t count;
104
105	if (caa_unlikely(!pc))
106	return 0;
107
108	do {
109	seq = CMM_LOAD_SHARED(pc->lock);
110	cmm_barrier();
111
112	idx = pc->index;
113	if (idx)
114	count = pc->offset + rdpmc(idx - 1);
115	else
116	count = 0;
117
118	cmm_barrier();
119	} while (CMM_LOAD_SHARED(pc->lock) != seq);
120
121	return count;
122	}
123
124	static
125	int sys_perf_event_open(struct perf_event_attr *attr,
126	pid_t pid, int cpu, int group_fd,
127	unsigned long flags)
128	{
129	return syscall(SYS_perf_event_open, attr, pid, cpu,
130	group_fd, flags);
131	}
132
133	static
134	struct perf_event_mmap_page setup_perf(struct perf_event_attr attr)
135	{
136	void *perf_addr;
137	int fd;
138
139	fd = sys_perf_event_open(attr, 0, -1, -1, 0);
140	if (fd < 0)
141	return NULL;
142
143	perf_addr = mmap(NULL, sizeof(struct perf_event_mmap_page),
144	PROT_READ, MAP_SHARED, fd, 0);
145	if (perf_addr == MAP_FAILED)
146	return NULL;
147	close(fd);
148	return perf_addr;
149	}
150
151	static
152	void unmap_perf_page(struct perf_event_mmap_page *pc)
153	{
154	int ret;
155
156	if (!pc)
157	return;
158	ret = munmap(pc, sizeof(struct perf_event_mmap_page));
159	if (ret < 0) {
160	PERROR("Error in munmap");
161	abort();
162	}
163	}
164
165	static
166	struct lttng_perf_counter_thread *alloc_perf_counter_thread(void)
167	{
168	struct lttng_perf_counter_thread *perf_thread;
169	sigset_t newmask, oldmask;
170	int ret;
171
172	ret = sigfillset(&newmask);
173	if (ret)
174	abort();
175	ret = pthread_sigmask(SIG_BLOCK, &newmask, &oldmask);
176	if (ret)
177	abort();
178	/* Check again with signals disabled */
179	perf_thread = pthread_getspecific(perf_counter_key);
180	if (perf_thread)
181	goto skip;
182	perf_thread = zmalloc(sizeof(*perf_thread));
183	if (!perf_thread)
184	abort();
185	CDS_INIT_LIST_HEAD(&perf_thread->rcu_field_list);
186	ret = pthread_setspecific(perf_counter_key, perf_thread);
187	if (ret)
188	abort();
189	skip:
190	ret = pthread_sigmask(SIG_SETMASK, &oldmask, NULL);
191	if (ret)
192	abort();
193	return perf_thread;
194	}
195
196	static
197	struct lttng_perf_counter_thread_field *
198	add_thread_field(struct lttng_perf_counter_field *perf_field,
199	struct lttng_perf_counter_thread *perf_thread)
200	{
201	struct lttng_perf_counter_thread_field *thread_field;
202	sigset_t newmask, oldmask;
203	int ret;
204
205	ret = sigfillset(&newmask);
206	if (ret)
207	abort();
208	ret = pthread_sigmask(SIG_BLOCK, &newmask, &oldmask);
209	if (ret)
210	abort();
211	/* Check again with signals disabled */
212	cds_list_for_each_entry_rcu(thread_field, &perf_thread->rcu_field_list,
213	rcu_field_node) {
214	if (thread_field->field == perf_field)
215	goto skip;
216	}
217	thread_field = zmalloc(sizeof(*thread_field));
218	if (!thread_field)
219	abort();
220	thread_field->field = perf_field;
221	thread_field->pc = setup_perf(&perf_field->attr);
222	/* Note: thread_field->pc can be NULL if setup_perf() fails. */
223	ust_lock_nocheck();
224	cds_list_add_rcu(&thread_field->rcu_field_node,
225	&perf_thread->rcu_field_list);
226	cds_list_add(&thread_field->thread_field_node,
227	&perf_field->thread_field_list);
228	ust_unlock();
229	skip:
230	ret = pthread_sigmask(SIG_SETMASK, &oldmask, NULL);
231	if (ret)
232	abort();
233	return thread_field;
234	}
235
236	static
237	struct lttng_perf_counter_thread_field *
238	get_thread_field(struct lttng_perf_counter_field *field)
239	{
240	struct lttng_perf_counter_thread *perf_thread;
241	struct lttng_perf_counter_thread_field *thread_field;
242
243	perf_thread = pthread_getspecific(perf_counter_key);
244	if (!perf_thread)
245	perf_thread = alloc_perf_counter_thread();
246	cds_list_for_each_entry_rcu(thread_field, &perf_thread->rcu_field_list,
247	rcu_field_node) {
248	if (thread_field->field == field)
249	return thread_field;
250	}
251	/* perf_counter_thread_field not found, need to add one */
252	return add_thread_field(field, perf_thread);
253	}
254
255	static
256	uint64_t wrapper_perf_counter_read(struct lttng_ctx_field *field)
257	{
258	struct lttng_perf_counter_field *perf_field;
259	struct lttng_perf_counter_thread_field *perf_thread_field;
260
261	perf_field = field->u.perf_counter;
262	perf_thread_field = get_thread_field(perf_field);
263	return read_perf_counter(perf_thread_field->pc);
264	}
265
266	static
267	void perf_counter_record(struct lttng_ctx_field *field,
268	struct lttng_ust_lib_ring_buffer_ctx *ctx,
269	struct lttng_channel *chan)
270	{
271	uint64_t value;
272
273	value = wrapper_perf_counter_read(field);
274	lib_ring_buffer_align_ctx(ctx, lttng_alignof(value));
275	chan->ops->event_write(ctx, &value, sizeof(value));
276	}
277
278	static
279	void perf_counter_get_value(struct lttng_ctx_field *field,
280	union lttng_ctx_value *value)
281	{
282	uint64_t v;
283
284	v = wrapper_perf_counter_read(field);
285	value->s64 = v;
286	}
287
288	/* Called with UST lock held */
289	static
290	void lttng_destroy_perf_thread_field(
291	struct lttng_perf_counter_thread_field *thread_field)
292	{
293	unmap_perf_page(thread_field->pc);
294	cds_list_del_rcu(&thread_field->rcu_field_node);
295	cds_list_del(&thread_field->thread_field_node);
296	free(thread_field);
297	}
298
299	static
300	void lttng_destroy_perf_thread_key(void *_key)
301	{
302	struct lttng_perf_counter_thread *perf_thread = _key;
303	struct lttng_perf_counter_thread_field pos, p;
304
305	ust_lock_nocheck();
306	cds_list_for_each_entry_safe(pos, p, &perf_thread->rcu_field_list,
307	rcu_field_node)
308	lttng_destroy_perf_thread_field(pos);
309	ust_unlock();
310	free(perf_thread);
311	}
312
313	/* Called with UST lock held */
314	static
315	void lttng_destroy_perf_counter_field(struct lttng_ctx_field *field)
316	{
317	struct lttng_perf_counter_field *perf_field;
318	struct lttng_perf_counter_thread_field pos, p;
319
320	free((char *) field->event_field.name);
321	perf_field = field->u.perf_counter;
322	/*
323	* This put is performed when no threads can concurrently
324	* perform a "get" concurrently, thanks to urcu-bp grace
325	* period.
326	*/
327	cds_list_for_each_entry_safe(pos, p, &perf_field->thread_field_list,
328	thread_field_node)
329	lttng_destroy_perf_thread_field(pos);
330	free(perf_field);
331	}
332
333	/* Called with UST lock held */
334	int lttng_add_perf_counter_to_ctx(uint32_t type,
335	uint64_t config,
336	const char *name,
337	struct lttng_ctx **ctx)
338	{
339	struct lttng_ctx_field *field;
340	struct lttng_perf_counter_field *perf_field;
341	struct perf_event_mmap_page *tmp_pc;
342	char *name_alloc;
343	int ret;
344
345	name_alloc = strdup(name);
346	if (!name_alloc) {
347	ret = -ENOMEM;
348	goto name_alloc_error;
349	}
350	perf_field = zmalloc(sizeof(*perf_field));
351	if (!perf_field) {
352	ret = -ENOMEM;
353	goto perf_field_alloc_error;
354	}
355	field = lttng_append_context(ctx);
356	if (!field) {
357	ret = -ENOMEM;
358	goto append_context_error;
359	}
360	if (lttng_find_context(*ctx, name_alloc)) {
361	ret = -EEXIST;
362	goto find_error;
363	}
364
365	field->destroy = lttng_destroy_perf_counter_field;
366
367	field->event_field.name = name_alloc;
368	field->event_field.type.atype = atype_integer;
369	field->event_field.type.u.basic.integer.size =
370	sizeof(uint64_t) * CHAR_BIT;
371	field->event_field.type.u.basic.integer.alignment =
372	lttng_alignof(uint64_t) * CHAR_BIT;
373	field->event_field.type.u.basic.integer.signedness =
374	lttng_is_signed_type(uint64_t);
375	field->event_field.type.u.basic.integer.reverse_byte_order = 0;
376	field->event_field.type.u.basic.integer.base = 10;
377	field->event_field.type.u.basic.integer.encoding = lttng_encode_none;
378	field->get_size = perf_counter_get_size;
379	field->record = perf_counter_record;
380	field->get_value = perf_counter_get_value;
381
382	perf_field->attr.type = type;
383	perf_field->attr.config = config;
384	perf_field->attr.exclude_kernel = 1;
385	CDS_INIT_LIST_HEAD(&perf_field->thread_field_list);
386	field->u.perf_counter = perf_field;
387
388	/* Ensure that this perf counter can be used in this process. */
389	tmp_pc = setup_perf(&perf_field->attr);
390	if (!tmp_pc) {
391	ret = -ENODEV;
392	goto setup_error;
393	}
394	unmap_perf_page(tmp_pc);
395
396	/*
397	* Contexts can only be added before tracing is started, so we
398	* don't have to synchronize against concurrent threads using
399	* the field here.
400	*/
401
402	return 0;
403
404	setup_error:
405	find_error:
406	lttng_remove_context_field(ctx, field);
407	append_context_error:
408	free(perf_field);
409	perf_field_alloc_error:
410	free(name_alloc);
411	name_alloc_error:
412	return ret;
413	}
414
415	int lttng_perf_counter_init(void)
416	{
417	int ret;
418
419	ret = pthread_key_create(&perf_counter_key,
420	lttng_destroy_perf_thread_key);
421	if (ret)
422	ret = -ret;
423	return ret;
424	}
425
426	void lttng_perf_counter_exit(void)
427	{
428	int ret;
429
430	ret = pthread_key_delete(perf_counter_key);
431	if (ret) {
432	errno = ret;
433	PERROR("Error in pthread_key_delete");
434	}
435	}