[linux-2.6-block.git] / tools / perf / util / comm.c

// SPDX-License-Identifier: GPL-2.0
#include "comm.h"
#include "util.h"
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <linux/refcount.h>

struct comm_str {
	char *str;
	struct rb_node rb_node;
	refcount_t refcnt;
};

/* Should perhaps be moved to struct machine */
static struct rb_root comm_str_root;

static struct comm_str *comm_str__get(struct comm_str *cs)
{
	if (cs)
		refcount_inc(&cs->refcnt);
	return cs;
}

static void comm_str__put(struct comm_str *cs)
{
	if (cs && refcount_dec_and_test(&cs->refcnt)) {
		rb_erase(&cs->rb_node, &comm_str_root);
		zfree(&cs->str);
		free(cs);
	}
}

static struct comm_str *comm_str__alloc(const char *str)
{
	struct comm_str *cs;

	cs = zalloc(sizeof(*cs));
	if (!cs)
		return NULL;

	cs->str = strdup(str);
	if (!cs->str) {
		free(cs);
		return NULL;
	}

	refcount_set(&cs->refcnt, 1);

	return cs;
}

static struct comm_str *comm_str__findnew(const char *str, struct rb_root *root)
{
	struct rb_node **p = &root->rb_node;
	struct rb_node *parent = NULL;
	struct comm_str *iter, *new;
	int cmp;

	while (*p != NULL) {
		parent = *p;
		iter = rb_entry(parent, struct comm_str, rb_node);

		cmp = strcmp(str, iter->str);
		if (!cmp)
			return comm_str__get(iter);

		if (cmp < 0)
			p = &(*p)->rb_left;
		else
			p = &(*p)->rb_right;
	}

	new = comm_str__alloc(str);
	if (!new)
		return NULL;

	rb_link_node(&new->rb_node, parent, p);
	rb_insert_color(&new->rb_node, root);

	return new;
}

struct comm *comm__new(const char *str, u64 timestamp, bool exec)
{
	struct comm *comm = zalloc(sizeof(*comm));

	if (!comm)
		return NULL;

	comm->start = timestamp;
	comm->exec = exec;

	comm->comm_str = comm_str__findnew(str, &comm_str_root);
	if (!comm->comm_str) {
		free(comm);
		return NULL;
	}

	return comm;
}

int comm__override(struct comm *comm, const char *str, u64 timestamp, bool exec)
{
	struct comm_str *new, *old = comm->comm_str;

	new = comm_str__findnew(str, &comm_str_root);
	if (!new)
		return -ENOMEM;

	comm_str__put(old);
	comm->comm_str = new;
	comm->start = timestamp;
	if (exec)
		comm->exec = true;

	return 0;
}

void comm__free(struct comm *comm)
{
	comm_str__put(comm->comm_str);
	free(comm);
}

const char *comm__str(const struct comm *comm)
{
	return comm->comm_str->str;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1902efe7 FW	2	#include "comm.h"
1902efe7 FW	3	#include "util.h"
a43783ae	4	#include <errno.h>
1902efe7 FW	5	#include <stdlib.h>
1902efe7 FW	6	#include <stdio.h>
72f7c4d2	7	#include <string.h>
6df74bc0	8	#include <linux/refcount.h>
1902efe7 FW	9
	10	struct comm_str {
	11	char *str;
	12	struct rb_node rb_node;
6df74bc0	13	refcount_t refcnt;
1902efe7 FW	14	};
	15
	16	/* Should perhaps be moved to struct machine */
	17	static struct rb_root comm_str_root;
	18
86c19525	19	static struct comm_str comm_str__get(struct comm_str cs)
1902efe7	20	{
86c19525	21	if (cs)
6df74bc0	22	refcount_inc(&cs->refcnt);
86c19525	23	return cs;
1902efe7 FW	24	}
	25
	26	static void comm_str__put(struct comm_str *cs)
	27	{
6df74bc0	28	if (cs && refcount_dec_and_test(&cs->refcnt)) {
1902efe7	29	rb_erase(&cs->rb_node, &comm_str_root);
74cf249d	30	zfree(&cs->str);
1902efe7 FW	31	free(cs);
	32	}
	33	}
	34
	35	static struct comm_str comm_str__alloc(const char str)
	36	{
	37	struct comm_str *cs;
	38
	39	cs = zalloc(sizeof(*cs));
	40	if (!cs)
	41	return NULL;
	42
	43	cs->str = strdup(str);
	44	if (!cs->str) {
	45	free(cs);
	46	return NULL;
	47	}
	48
6df74bc0	49	refcount_set(&cs->refcnt, 1);
86c19525	50
1902efe7 FW	51	return cs;
	52	}
	53
	54	static struct comm_str comm_str__findnew(const char str, struct rb_root *root)
	55	{
	56	struct rb_node **p = &root->rb_node;
	57	struct rb_node *parent = NULL;
	58	struct comm_str iter, new;
	59	int cmp;
	60
	61	while (*p != NULL) {
	62	parent = *p;
	63	iter = rb_entry(parent, struct comm_str, rb_node);
	64
	65	cmp = strcmp(str, iter->str);
	66	if (!cmp)
6df74bc0	67	return comm_str__get(iter);
1902efe7 FW	68
	69	if (cmp < 0)
	70	p = &(*p)->rb_left;
	71	else
	72	p = &(*p)->rb_right;
	73	}
	74
	75	new = comm_str__alloc(str);
	76	if (!new)
	77	return NULL;
	78
	79	rb_link_node(&new->rb_node, parent, p);
	80	rb_insert_color(&new->rb_node, root);
	81
	82	return new;
	83	}
	84
65de51f9	85	struct comm comm__new(const char str, u64 timestamp, bool exec)
1902efe7 FW	86	{
	87	struct comm comm = zalloc(sizeof(comm));
	88
	89	if (!comm)
	90	return NULL;
	91
	92	comm->start = timestamp;
65de51f9	93	comm->exec = exec;
1902efe7 FW	94
	95	comm->comm_str = comm_str__findnew(str, &comm_str_root);
	96	if (!comm->comm_str) {
	97	free(comm);
	98	return NULL;
	99	}
	100
1902efe7 FW	101	return comm;
	102	}
	103
65de51f9	104	int comm__override(struct comm comm, const char str, u64 timestamp, bool exec)
4dfced35	105	{
3178f58b	106	struct comm_str new, old = comm->comm_str;
4dfced35	107
3178f58b FW	108	new = comm_str__findnew(str, &comm_str_root);
	109	if (!new)
	110	return -ENOMEM;
4dfced35	111
4dfced35	112	comm_str__put(old);
3178f58b FW	113	comm->comm_str = new;
3178f58b FW	114	comm->start = timestamp;
65de51f9 AH	115	if (exec)
65de51f9 AH	116	comm->exec = true;
3178f58b FW	117
3178f58b FW	118	return 0;
4dfced35 NK	119	}
4dfced35 NK	120
1902efe7 FW	121	void comm__free(struct comm *comm)
	122	{
	123	comm_str__put(comm->comm_str);
	124	free(comm);
	125	}
	126
	127	const char comm__str(const struct comm comm)
	128	{
	129	return comm->comm_str->str;
	130	}