444ff6eeea9f6b79c1c93259890927b52a27bf28
[lttng-tools.git] / lttng-sessiond / ust-consumer.c
1 /*
2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the Free
6 * Software Foundation; only version 2 of the License.
7 *
8 * This program is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11 * more details.
12 *
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15 * Place - Suite 330, Boston, MA 02111-1307, USA.
16 */
17
18 #define _GNU_SOURCE
19 #include <errno.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <unistd.h>
24
25 #include <lttngerr.h>
26 #include <lttng-share.h>
27 #include <lttng-sessiond-comm.h>
28 #include <lttng/lttng-consumer.h>
29
30 #include "hashtable.h"
31 #include "ust-consumer.h"
32
33 /*
34 * Send all stream fds of UST channel to the consumer.
35 */
36 static int send_channel_streams(int sock,
37 struct ust_app_channel *uchan)
38 {
39 int ret, fd;
40 struct lttcomm_consumer_msg lum;
41 struct ltt_ust_stream *stream;
42
43 DBG("Sending streams of channel %s to UST consumer", uchan->name);
44
45 /* Send channel */
46 lum.cmd_type = LTTNG_CONSUMER_ADD_CHANNEL;
47
48 /*
49 * We need to keep shm_fd open to make sure this key stays unique within
50 * the session daemon.
51 */
52 lum.u.channel.channel_key = uchan->obj->shm_fd;
53 lum.u.channel.max_sb_size = uchan->attr.subbuf_size;
54 lum.u.channel.mmap_len = uchan->obj->memory_map_size;
55 DBG("Sending channel %d to consumer", lum.u.channel.channel_key);
56 ret = lttcomm_send_unix_sock(sock, &lum, sizeof(lum));
57 if (ret < 0) {
58 perror("send consumer channel");
59 goto error;
60 }
61 fd = uchan->obj->shm_fd;
62 ret = lttcomm_send_fds_unix_sock(sock, &fd, 1);
63 if (ret < 0) {
64 perror("send consumer channel ancillary data");
65 goto error;
66 }
67
68 cds_list_for_each_entry(stream, &uchan->streams.head, list) {
69 int fds[2];
70
71 if (!stream->obj->shm_fd) {
72 continue;
73 }
74 lum.cmd_type = LTTNG_CONSUMER_ADD_STREAM;
75 lum.u.stream.channel_key = uchan->obj->shm_fd;
76 lum.u.stream.stream_key = stream->obj->shm_fd;
77 lum.u.stream.state = LTTNG_CONSUMER_ACTIVE_STREAM;
78 lum.u.stream.output = uchan->attr.output;
79 lum.u.stream.mmap_len = stream->obj->memory_map_size;
80 strncpy(lum.u.stream.path_name, stream->pathname, PATH_MAX - 1);
81 lum.u.stream.path_name[PATH_MAX - 1] = '\0';
82 DBG("Sending stream %d to consumer", lum.u.stream.stream_key);
83 ret = lttcomm_send_unix_sock(sock, &lum, sizeof(lum));
84 if (ret < 0) {
85 perror("send consumer stream");
86 goto error;
87 }
88
89 fds[0] = stream->obj->shm_fd;
90 fds[1] = stream->obj->wait_fd;
91 ret = lttcomm_send_fds_unix_sock(sock, fds, 2);
92 if (ret < 0) {
93 perror("send consumer stream ancillary data");
94 goto error;
95 }
96 }
97
98 DBG("consumer channel streams sent");
99
100 return 0;
101
102 error:
103 return ret;
104 }
105
106 /*
107 * Send all stream fds of the UST session to the consumer.
108 */
109 int ust_consumer_send_session(int consumer_fd, struct ust_app_session *usess)
110 {
111 int ret = 0;
112 int sock = consumer_fd;
113 struct cds_lfht_iter iter;
114 struct cds_lfht_node *node;
115 struct lttcomm_consumer_msg lum;
116 struct ust_app_channel *uchan;
117
118 DBG("Sending metadata stream fd");
119
120 if (usess->metadata->obj->shm_fd != 0) {
121 int fd;
122 int fds[2];
123
124 /* Send metadata channel fd */
125 lum.cmd_type = LTTNG_CONSUMER_ADD_CHANNEL;
126 lum.u.channel.channel_key = usess->metadata->obj->shm_fd;
127 lum.u.channel.max_sb_size = usess->metadata->attr.subbuf_size;
128 lum.u.channel.mmap_len = usess->metadata->obj->memory_map_size;
129 DBG("Sending metadata channel %d to consumer", lum.u.channel.channel_key);
130 ret = lttcomm_send_unix_sock(sock, &lum, sizeof(lum));
131 if (ret < 0) {
132 perror("send consumer channel");
133 goto error;
134 }
135 fd = usess->metadata->obj->shm_fd;
136 ret = lttcomm_send_fds_unix_sock(sock, &fd, 1);
137 if (ret < 0) {
138 perror("send consumer metadata channel");
139 goto error;
140 }
141
142 /* Send metadata stream fd */
143 lum.cmd_type = LTTNG_CONSUMER_ADD_STREAM;
144 lum.u.stream.channel_key = usess->metadata->obj->shm_fd;
145 lum.u.stream.stream_key = usess->metadata->stream_obj->shm_fd;
146 lum.u.stream.state = LTTNG_CONSUMER_ACTIVE_STREAM;
147 lum.u.stream.output = DEFAULT_UST_CHANNEL_OUTPUT;
148 lum.u.stream.mmap_len = usess->metadata->stream_obj->memory_map_size;
149 strncpy(lum.u.stream.path_name, usess->metadata->pathname, PATH_MAX - 1);
150 lum.u.stream.path_name[PATH_MAX - 1] = '\0';
151 DBG("Sending metadata stream %d to consumer", lum.u.stream.stream_key);
152 ret = lttcomm_send_unix_sock(sock, &lum, sizeof(lum));
153 if (ret < 0) {
154 perror("send consumer metadata stream");
155 goto error;
156 }
157 fds[0] = usess->metadata->stream_obj->shm_fd;
158 fds[1] = usess->metadata->stream_obj->wait_fd;
159 ret = lttcomm_send_fds_unix_sock(sock, fds, 2);
160 if (ret < 0) {
161 perror("send consumer stream");
162 goto error;
163 }
164 }
165
166 /* Send each channel fd streams of session */
167 rcu_read_lock();
168 hashtable_get_first(usess->channels, &iter);
169 while ((node = hashtable_iter_get_node(&iter)) != NULL) {
170 uchan = caa_container_of(node, struct ust_app_channel, node);
171
172 ret = send_channel_streams(sock, uchan);
173 if (ret < 0) {
174 goto error;
175 }
176 hashtable_get_next(usess->channels, &iter);
177 }
178 rcu_read_unlock();
179
180 DBG("consumer fds (metadata and channel streams) sent");
181
182 return 0;
183
184 error:
185 return ret;
186 }
This page took 0.041152 seconds and 3 git commands to generate.