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