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

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