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}

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