[lttng-tools.git] / ltt-sessiond / ust-app.c

/*
 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; only version 2
 * of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#define _GNU_SOURCE
#include <errno.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <lttngerr.h>

#include "hashtable.h"
#include "ust-app.h"
#include "../hashtable/hash.h"

/*
 * Delete a traceable application structure from the global list.
 */
static void delete_ust_app(struct ust_app *lta)
{
	int ret;
	struct cds_lfht_node *node;
	struct cds_lfht_iter iter;

	rcu_read_lock();

	hashtable_get_first(lta->channels, &iter);
	while ((node = hashtable_iter_get_node(&iter)) != NULL) {
		ret = hashtable_del(lta->channels, &iter);
		if (!ret) {
			trace_ust_destroy_channel(
					caa_container_of(node, struct ltt_ust_channel, node));
		}
		hashtable_get_next(lta->channels, &iter);
	}

	free(lta->channels);
	close(lta->key.sock);

	/* Remove from apps hash table */
	node = hashtable_lookup(ust_app_ht,
			(void *) ((unsigned long) lta->key.pid), sizeof(void *), &iter);
	if (node == NULL) {
		ERR("UST app pid %d not found in hash table", lta->key.pid);
	} else {
		ret = hashtable_del(ust_app_ht, &iter);
		if (ret) {
			ERR("UST app unable to delete app %d from hash table",
					lta->key.pid);
		} else {
			DBG2("UST app pid %d deleted", lta->key.pid);
		}
	}

	/* Remove from key hash table */
	node = hashtable_lookup(ust_app_sock_key_map,
			(void *) ((unsigned long) lta->key.sock), sizeof(void *), &iter);
	if (node == NULL) {
		ERR("UST app key %d not found in key hash table", lta->key.sock);
	} else {
		ret = hashtable_del(ust_app_sock_key_map, &iter);
		if (ret) {
			ERR("UST app unable to delete app sock %d from key hash table",
					lta->key.sock);
		} else {
			DBG2("UST app pair sock %d key %d deleted",
					lta->key.sock, lta->key.pid);
		}
	}

	free(lta);

	rcu_read_unlock();
}

/*
 * URCU intermediate call to delete an UST app.
 */
static void delete_ust_app_rcu(struct rcu_head *head)
{
	struct cds_lfht_node *node =
		caa_container_of(head, struct cds_lfht_node, head);
	struct ust_app *app =
		caa_container_of(node, struct ust_app, node);

	delete_ust_app(app);
}

/*
 * Find an ust_app using the sock and return it.
 */
static struct ust_app *find_app_by_sock(int sock)
{
	struct cds_lfht_node *node;
	struct ust_app_key *key;
	struct cds_lfht_iter iter;
	//struct ust_app *app;

	rcu_read_lock();

	node = hashtable_lookup(ust_app_sock_key_map,
			(void *)((unsigned long) sock), sizeof(void *), &iter);
	if (node == NULL) {
		DBG2("UST app find by sock %d key not found", sock);
		rcu_read_unlock();
		goto error;
	}

	key = caa_container_of(node, struct ust_app_key, node);

	node = hashtable_lookup(ust_app_ht,
			(void *)((unsigned long) key->pid), sizeof(void *), &iter);
	if (node == NULL) {
		DBG2("UST app find by sock %d not found", sock);
		rcu_read_unlock();
		goto error;
	}
	rcu_read_unlock();

	return caa_container_of(node, struct ust_app, node);

error:
	return NULL;
}

/*
 * Return pointer to traceable apps list.
 */
struct cds_lfht *ust_app_get_ht(void)
{
	return ust_app_ht;
}

/*
 * Return ust app pointer or NULL if not found.
 */
struct ust_app *ust_app_find_by_pid(pid_t pid)
{
	struct cds_lfht_node *node;
	struct cds_lfht_iter iter;

	rcu_read_lock();
	node = hashtable_lookup(ust_app_ht,
			(void *)((unsigned long) pid), sizeof(void *), &iter);
	if (node == NULL) {
		rcu_read_unlock();
		DBG2("UST app no found with pid %d", pid);
		goto error;
	}
	rcu_read_unlock();

	DBG2("Found UST app by pid %d", pid);

	return caa_container_of(node, struct ust_app, node);

error:
	return NULL;
}

/*
 * Using pid and uid (of the app), allocate a new ust_app struct and
 * add it to the global traceable app list.
 *
 * On success, return 0, else return malloc ENOMEM.
 */
int ust_app_register(struct ust_register_msg *msg, int sock)
{
	struct ust_app *lta;

	lta = malloc(sizeof(struct ust_app));
	if (lta == NULL) {
		perror("malloc");
		return -ENOMEM;
	}

	lta->uid = msg->uid;
	lta->gid = msg->gid;
	lta->key.pid = msg->pid;
	lta->ppid = msg->ppid;
	lta->v_major = msg->major;
	lta->v_minor = msg->minor;
	lta->key.sock = sock;
	strncpy(lta->name, msg->name, sizeof(lta->name));
	lta->name[16] = '\0';
	hashtable_node_init(&lta->node, (void *)((unsigned long)lta->key.pid),
			sizeof(void *));
	lta->channels = hashtable_new_str(0);

	/* Set sock key map */
	hashtable_node_init(&lta->key.node, (void *)((unsigned long)lta->key.sock),
			sizeof(void *));

	rcu_read_lock();
	hashtable_add_unique(ust_app_ht, &lta->node);
	hashtable_add_unique(ust_app_sock_key_map, &lta->key.node);
	rcu_read_unlock();

	DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s"
			" (version %d.%d)", lta->key.pid, lta->ppid, lta->uid, lta->gid,
			lta->key.sock, lta->name, lta->v_major, lta->v_minor);

	return 0;
}

/*
 * Unregister app by removing it from the global traceable app list and freeing
 * the data struct.
 *
 * The socket is already closed at this point so no close to sock.
 */
void ust_app_unregister(int sock)
{
	struct ust_app *lta;

	DBG2("UST app unregistering sock %d", sock);

	lta = find_app_by_sock(sock);
	if (lta) {
		DBG("PID %d unregistering with sock %d", lta->key.pid, sock);
		/* FIXME: Better use a call_rcu here ? */
		delete_ust_app(lta);
	}
}

/*
 * Return traceable_app_count
 */
unsigned long ust_app_list_count(void)
{
	unsigned long count;

	rcu_read_lock();
	count = hashtable_get_count(ust_app_ht);
	rcu_read_unlock();

	return count;
}

/*
 * Free and clean all traceable apps of the global list.
 */
void ust_app_clean_list(void)
{
	int ret;
	struct cds_lfht_node *node;
	struct cds_lfht_iter iter;

	DBG2("UST app clean hash table");

	rcu_read_lock();

	hashtable_get_first(ust_app_ht, &iter);
	while ((node = hashtable_iter_get_node(&iter)) != NULL) {
		ret = hashtable_del(ust_app_ht, &iter);
		if (!ret) {
			call_rcu(&node->head, delete_ust_app_rcu);
		}
		hashtable_get_next(ust_app_ht, &iter);
	}

	rcu_read_unlock();
}

/*
 * Init UST app hash table.
 */
void ust_app_ht_alloc(void)
{
	ust_app_ht = hashtable_new(0);
	ust_app_sock_key_map = hashtable_new(0);
}
Commit	Line	Data
	1	/*
	2	* Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation; only version 2
	7	* of the License.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	17	*/
	18
	19	#define _GNU_SOURCE
	20	#include <errno.h>
	21	#include <pthread.h>
	22	#include <stdio.h>
	23	#include <stdlib.h>
	24	#include <string.h>
	25	#include <unistd.h>
	26
	27	#include <lttngerr.h>
	28
	29	#include "hashtable.h"
	30	#include "ust-app.h"
	31	#include "../hashtable/hash.h"
	32
	33	/*
	34	* Delete a traceable application structure from the global list.
	35	*/
	36	static void delete_ust_app(struct ust_app *lta)
	37	{
	38	int ret;
	39	struct cds_lfht_node *node;
	40	struct cds_lfht_iter iter;
	41
	42	rcu_read_lock();
	43
	44	hashtable_get_first(lta->channels, &iter);
	45	while ((node = hashtable_iter_get_node(&iter)) != NULL) {
	46	ret = hashtable_del(lta->channels, &iter);
	47	if (!ret) {
	48	trace_ust_destroy_channel(
	49	caa_container_of(node, struct ltt_ust_channel, node));
	50	}
	51	hashtable_get_next(lta->channels, &iter);
	52	}
	53
	54	free(lta->channels);
	55	close(lta->key.sock);
	56
	57	/* Remove from apps hash table */
	58	node = hashtable_lookup(ust_app_ht,
	59	(void ) ((unsigned long) lta->key.pid), sizeof(void ), &iter);
	60	if (node == NULL) {
	61	ERR("UST app pid %d not found in hash table", lta->key.pid);
	62	} else {
	63	ret = hashtable_del(ust_app_ht, &iter);
	64	if (ret) {
	65	ERR("UST app unable to delete app %d from hash table",
	66	lta->key.pid);
	67	} else {
	68	DBG2("UST app pid %d deleted", lta->key.pid);
	69	}
	70	}
	71
	72	/* Remove from key hash table */
	73	node = hashtable_lookup(ust_app_sock_key_map,
	74	(void ) ((unsigned long) lta->key.sock), sizeof(void ), &iter);
	75	if (node == NULL) {
	76	ERR("UST app key %d not found in key hash table", lta->key.sock);
	77	} else {
	78	ret = hashtable_del(ust_app_sock_key_map, &iter);
	79	if (ret) {
	80	ERR("UST app unable to delete app sock %d from key hash table",
	81	lta->key.sock);
	82	} else {
	83	DBG2("UST app pair sock %d key %d deleted",
	84	lta->key.sock, lta->key.pid);
	85	}
	86	}
	87
	88	free(lta);
	89
	90	rcu_read_unlock();
	91	}
	92
	93	/*
	94	* URCU intermediate call to delete an UST app.
	95	*/
	96	static void delete_ust_app_rcu(struct rcu_head *head)
	97	{
	98	struct cds_lfht_node *node =
	99	caa_container_of(head, struct cds_lfht_node, head);
	100	struct ust_app *app =
	101	caa_container_of(node, struct ust_app, node);
	102
	103	delete_ust_app(app);
	104	}
	105
	106	/*
	107	* Find an ust_app using the sock and return it.
	108	*/
	109	static struct ust_app *find_app_by_sock(int sock)
	110	{
	111	struct cds_lfht_node *node;
	112	struct ust_app_key *key;
	113	struct cds_lfht_iter iter;
	114	//struct ust_app *app;
	115
	116	rcu_read_lock();
	117
	118	node = hashtable_lookup(ust_app_sock_key_map,
	119	(void )((unsigned long) sock), sizeof(void ), &iter);
	120	if (node == NULL) {
	121	DBG2("UST app find by sock %d key not found", sock);
	122	rcu_read_unlock();
	123	goto error;
	124	}
	125
	126	key = caa_container_of(node, struct ust_app_key, node);
	127
	128	node = hashtable_lookup(ust_app_ht,
	129	(void )((unsigned long) key->pid), sizeof(void ), &iter);
	130	if (node == NULL) {
	131	DBG2("UST app find by sock %d not found", sock);
	132	rcu_read_unlock();
	133	goto error;
	134	}
	135	rcu_read_unlock();
	136
	137	return caa_container_of(node, struct ust_app, node);
	138
	139	error:
	140	return NULL;
	141	}
	142
	143	/*
	144	* Return pointer to traceable apps list.
	145	*/
	146	struct cds_lfht *ust_app_get_ht(void)
	147	{
	148	return ust_app_ht;
	149	}
	150
	151	/*
	152	* Return ust app pointer or NULL if not found.
	153	*/
	154	struct ust_app *ust_app_find_by_pid(pid_t pid)
	155	{
	156	struct cds_lfht_node *node;
	157	struct cds_lfht_iter iter;
	158
	159	rcu_read_lock();
	160	node = hashtable_lookup(ust_app_ht,
	161	(void )((unsigned long) pid), sizeof(void ), &iter);
	162	if (node == NULL) {
	163	rcu_read_unlock();
	164	DBG2("UST app no found with pid %d", pid);
	165	goto error;
	166	}
	167	rcu_read_unlock();
	168
	169	DBG2("Found UST app by pid %d", pid);
	170
	171	return caa_container_of(node, struct ust_app, node);
	172
	173	error:
	174	return NULL;
	175	}
	176
	177	/*
	178	* Using pid and uid (of the app), allocate a new ust_app struct and
	179	* add it to the global traceable app list.
	180	*
	181	* On success, return 0, else return malloc ENOMEM.
	182	*/
	183	int ust_app_register(struct ust_register_msg *msg, int sock)
	184	{
	185	struct ust_app *lta;
	186
	187	lta = malloc(sizeof(struct ust_app));
	188	if (lta == NULL) {
	189	perror("malloc");
	190	return -ENOMEM;
	191	}
	192
	193	lta->uid = msg->uid;
	194	lta->gid = msg->gid;
	195	lta->key.pid = msg->pid;
	196	lta->ppid = msg->ppid;
	197	lta->v_major = msg->major;
	198	lta->v_minor = msg->minor;
	199	lta->key.sock = sock;
	200	strncpy(lta->name, msg->name, sizeof(lta->name));
	201	lta->name[16] = '\0';
	202	hashtable_node_init(&lta->node, (void *)((unsigned long)lta->key.pid),
	203	sizeof(void *));
	204	lta->channels = hashtable_new_str(0);
	205
	206	/* Set sock key map */
	207	hashtable_node_init(&lta->key.node, (void *)((unsigned long)lta->key.sock),
	208	sizeof(void *));
	209
	210	rcu_read_lock();
	211	hashtable_add_unique(ust_app_ht, &lta->node);
	212	hashtable_add_unique(ust_app_sock_key_map, &lta->key.node);
	213	rcu_read_unlock();
	214
	215	DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s"
	216	" (version %d.%d)", lta->key.pid, lta->ppid, lta->uid, lta->gid,
	217	lta->key.sock, lta->name, lta->v_major, lta->v_minor);
	218
	219	return 0;
	220	}
	221
	222	/*
	223	* Unregister app by removing it from the global traceable app list and freeing
	224	* the data struct.
	225	*
	226	* The socket is already closed at this point so no close to sock.
	227	*/
	228	void ust_app_unregister(int sock)
	229	{
	230	struct ust_app *lta;
	231
	232	DBG2("UST app unregistering sock %d", sock);
	233
	234	lta = find_app_by_sock(sock);
	235	if (lta) {
	236	DBG("PID %d unregistering with sock %d", lta->key.pid, sock);
	237	/* FIXME: Better use a call_rcu here ? */
	238	delete_ust_app(lta);
	239	}
	240	}
	241
	242	/*
	243	* Return traceable_app_count
	244	*/
	245	unsigned long ust_app_list_count(void)
	246	{
	247	unsigned long count;
	248
	249	rcu_read_lock();
	250	count = hashtable_get_count(ust_app_ht);
	251	rcu_read_unlock();
	252
	253	return count;
	254	}
	255
	256	/*
	257	* Free and clean all traceable apps of the global list.
	258	*/
	259	void ust_app_clean_list(void)
	260	{
	261	int ret;
	262	struct cds_lfht_node *node;
	263	struct cds_lfht_iter iter;
	264
	265	DBG2("UST app clean hash table");
	266
	267	rcu_read_lock();
	268
	269	hashtable_get_first(ust_app_ht, &iter);
	270	while ((node = hashtable_iter_get_node(&iter)) != NULL) {
	271	ret = hashtable_del(ust_app_ht, &iter);
	272	if (!ret) {
	273	call_rcu(&node->head, delete_ust_app_rcu);
	274	}
	275	hashtable_get_next(ust_app_ht, &iter);
	276	}
	277
	278	rcu_read_unlock();
	279	}
	280
	281	/*
	282	* Init UST app hash table.
	283	*/
	284	void ust_app_ht_alloc(void)
	285	{
	286	ust_app_ht = hashtable_new(0);
	287	ust_app_sock_key_map = hashtable_new(0);
	288	}