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#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}