Add UST namespace contexts
[lttng-tools.git] / src / bin / lttng-relayd / connection.c
1 /*
2 * Copyright (C) 2013 - Julien Desfossez <jdesfossez@efficios.com>
3 * David Goulet <dgoulet@efficios.com>
4 * 2015 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License, version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc., 51
17 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20 #define _LGPL_SOURCE
21 #include <common/common.h>
22 #include <urcu/rculist.h>
23
24 #include "connection.h"
25 #include "stream.h"
26 #include "viewer-session.h"
27
28 bool connection_get(struct relay_connection *conn)
29 {
30 return urcu_ref_get_unless_zero(&conn->ref);
31 }
32
33 struct relay_connection *connection_get_by_sock(struct lttng_ht *relay_connections_ht,
34 int sock)
35 {
36 struct lttng_ht_node_ulong *node;
37 struct lttng_ht_iter iter;
38 struct relay_connection *conn = NULL;
39
40 assert(sock >= 0);
41
42 rcu_read_lock();
43 lttng_ht_lookup(relay_connections_ht, (void *)((unsigned long) sock),
44 &iter);
45 node = lttng_ht_iter_get_node_ulong(&iter);
46 if (!node) {
47 DBG2("Relay connection by sock %d not found", sock);
48 goto end;
49 }
50 conn = caa_container_of(node, struct relay_connection, sock_n);
51 if (!connection_get(conn)) {
52 conn = NULL;
53 }
54 end:
55 rcu_read_unlock();
56 return conn;
57 }
58
59 int connection_reset_protocol_state(struct relay_connection *connection)
60 {
61 int ret = 0;
62
63 switch (connection->type) {
64 case RELAY_DATA:
65 connection->protocol.data.state_id =
66 DATA_CONNECTION_STATE_RECEIVE_HEADER;
67 memset(&connection->protocol.data.state.receive_header,
68 0,
69 sizeof(connection->protocol.data.state.receive_header));
70 connection->protocol.data.state.receive_header.left_to_receive =
71 sizeof(struct lttcomm_relayd_data_hdr);
72 break;
73 case RELAY_CONTROL:
74 connection->protocol.ctrl.state_id =
75 CTRL_CONNECTION_STATE_RECEIVE_HEADER;
76 memset(&connection->protocol.ctrl.state.receive_header,
77 0,
78 sizeof(connection->protocol.ctrl.state.receive_header));
79 connection->protocol.data.state.receive_header.left_to_receive =
80 sizeof(struct lttcomm_relayd_hdr);
81 ret = lttng_dynamic_buffer_set_size(
82 &connection->protocol.ctrl.reception_buffer,
83 sizeof(struct lttcomm_relayd_hdr));
84 if (ret) {
85 ERR("Failed to reinitialize control connection reception buffer size to %zu bytes.", sizeof(struct lttcomm_relayd_hdr));
86 goto end;
87 }
88 break;
89 default:
90 goto end;
91 }
92 DBG("Reset communication state of relay connection (fd = %i)",
93 connection->sock->fd);
94 end:
95 return ret;
96 }
97
98 struct relay_connection *connection_create(struct lttcomm_sock *sock,
99 enum connection_type type)
100 {
101 struct relay_connection *conn;
102
103 conn = zmalloc(sizeof(*conn));
104 if (!conn) {
105 PERROR("zmalloc relay connection");
106 goto end;
107 }
108 urcu_ref_init(&conn->ref);
109 conn->type = type;
110 conn->sock = sock;
111 lttng_ht_node_init_ulong(&conn->sock_n, (unsigned long) conn->sock->fd);
112 if (conn->type == RELAY_CONTROL) {
113 lttng_dynamic_buffer_init(&conn->protocol.ctrl.reception_buffer);
114 }
115 connection_reset_protocol_state(conn);
116 end:
117 return conn;
118 }
119
120 static void rcu_free_connection(struct rcu_head *head)
121 {
122 struct relay_connection *conn =
123 caa_container_of(head, struct relay_connection, rcu_node);
124
125 lttcomm_destroy_sock(conn->sock);
126 if (conn->viewer_session) {
127 viewer_session_destroy(conn->viewer_session);
128 conn->viewer_session = NULL;
129 }
130 if (conn->type == RELAY_CONTROL) {
131 lttng_dynamic_buffer_reset(
132 &conn->protocol.ctrl.reception_buffer);
133 }
134 free(conn);
135 }
136
137 static void destroy_connection(struct relay_connection *conn)
138 {
139 call_rcu(&conn->rcu_node, rcu_free_connection);
140 }
141
142 static void connection_release(struct urcu_ref *ref)
143 {
144 struct relay_connection *conn =
145 caa_container_of(ref, struct relay_connection, ref);
146
147 if (conn->in_socket_ht) {
148 struct lttng_ht_iter iter;
149 int ret;
150
151 iter.iter.node = &conn->sock_n.node;
152 ret = lttng_ht_del(conn->socket_ht, &iter);
153 assert(!ret);
154 }
155
156 if (conn->session) {
157 if (session_close(conn->session)) {
158 ERR("session_close");
159 }
160 conn->session = NULL;
161 }
162 if (conn->viewer_session) {
163 viewer_session_close(conn->viewer_session);
164 }
165 destroy_connection(conn);
166 }
167
168 void connection_put(struct relay_connection *conn)
169 {
170 rcu_read_lock();
171 urcu_ref_put(&conn->ref, connection_release);
172 rcu_read_unlock();
173 }
174
175 void connection_ht_add(struct lttng_ht *relay_connections_ht,
176 struct relay_connection *conn)
177 {
178 assert(!conn->in_socket_ht);
179 lttng_ht_add_unique_ulong(relay_connections_ht, &conn->sock_n);
180 conn->in_socket_ht = 1;
181 conn->socket_ht = relay_connections_ht;
182 }
183
184 int connection_set_session(struct relay_connection *conn,
185 struct relay_session *session)
186 {
187 int ret = 0;
188
189 assert(conn);
190 assert(session);
191 assert(!conn->session);
192
193 if (connection_get(conn)) {
194 if (session_get(session)) {
195 conn->session = session;
196 } else {
197 ERR("Failed to get session reference in connection_set_session()");
198 ret = -1;
199 }
200 connection_put(conn);
201 } else {
202 ERR("Failed to get connection reference in connection_set_session()");
203 ret = -1;
204 }
205 return ret;
206 }
This page took 0.033252 seconds and 4 git commands to generate.