3764c125397f4a8905d022d89953dde19cefc484
[lttng-tools.git] / src / bin / lttng-sessiond / session.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
5 * it under the terms of the GNU General Public License, version 2 only,
6 * as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16 */
17
18 #define _GNU_SOURCE
19 #include <limits.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <sys/stat.h>
24 #include <urcu.h>
25
26 #include <common/common.h>
27 #include <common/sessiond-comm/sessiond-comm.h>
28
29 #include "session.h"
30
31 /*
32 * NOTES:
33 *
34 * No ltt_session.lock is taken here because those data structure are widely
35 * spread across the lttng-tools code base so before caling functions below
36 * that can read/write a session, the caller MUST acquire the session lock
37 * using session_lock() and session_unlock().
38 */
39
40 /*
41 * Init tracing session list.
42 *
43 * Please see session.h for more explanation and correct usage of the list.
44 */
45 static struct ltt_session_list ltt_session_list = {
46 .head = CDS_LIST_HEAD_INIT(ltt_session_list.head),
47 .lock = PTHREAD_MUTEX_INITIALIZER,
48 .next_uuid = 0,
49 };
50
51 /*
52 * Add a ltt_session structure to the global list.
53 *
54 * The caller MUST acquire the session list lock before.
55 * Returns the unique identifier for the session.
56 */
57 static unsigned int add_session_list(struct ltt_session *ls)
58 {
59 cds_list_add(&ls->list, &ltt_session_list.head);
60 return ltt_session_list.next_uuid++;
61 }
62
63 /*
64 * Delete a ltt_session structure to the global list.
65 *
66 * The caller MUST acquire the session list lock before.
67 */
68 static void del_session_list(struct ltt_session *ls)
69 {
70 cds_list_del(&ls->list);
71 }
72
73 /*
74 * Return a pointer to the session list.
75 */
76 struct ltt_session_list *session_get_list(void)
77 {
78 return &ltt_session_list;
79 }
80
81 /*
82 * Acquire session list lock
83 */
84 void session_lock_list(void)
85 {
86 pthread_mutex_lock(&ltt_session_list.lock);
87 }
88
89 /*
90 * Release session list lock
91 */
92 void session_unlock_list(void)
93 {
94 pthread_mutex_unlock(&ltt_session_list.lock);
95 }
96
97 /*
98 * Acquire session lock
99 */
100 void session_lock(struct ltt_session *session)
101 {
102 pthread_mutex_lock(&session->lock);
103 }
104
105 /*
106 * Release session lock
107 */
108 void session_unlock(struct ltt_session *session)
109 {
110 pthread_mutex_unlock(&session->lock);
111 }
112
113 /*
114 * Return a ltt_session structure ptr that matches name. If no session found,
115 * NULL is returned. This must be called with the session lock held using
116 * session_lock_list and session_unlock_list.
117 */
118 struct ltt_session *session_find_by_name(char *name)
119 {
120 struct ltt_session *iter;
121
122 DBG2("Trying to find session by name %s", name);
123
124 cds_list_for_each_entry(iter, &ltt_session_list.head, list) {
125 if (strncmp(iter->name, name, NAME_MAX) == 0) {
126 goto found;
127 }
128 }
129
130 iter = NULL;
131
132 found:
133 return iter;
134 }
135
136 /*
137 * Delete session from the session list and free the memory.
138 *
139 * Return -1 if no session is found. On success, return 1;
140 */
141 int session_destroy(struct ltt_session *session)
142 {
143 /* Safety check */
144 if (session == NULL) {
145 ERR("Session pointer was null on session destroy");
146 return LTTCOMM_OK;
147 }
148
149 DBG("Destroying session %s", session->name);
150 del_session_list(session);
151 pthread_mutex_destroy(&session->lock);
152
153 rcu_read_lock();
154 consumer_destroy_output(session->consumer);
155 rcu_read_unlock();
156 free(session);
157
158 return LTTCOMM_OK;
159 }
160
161 /*
162 * Create a brand new session and add it to the session list.
163 */
164 int session_create(char *name, char *path, uid_t uid, gid_t gid)
165 {
166 int ret;
167 struct ltt_session *new_session;
168
169 /* Allocate session data structure */
170 new_session = zmalloc(sizeof(struct ltt_session));
171 if (new_session == NULL) {
172 PERROR("zmalloc");
173 ret = LTTCOMM_FATAL;
174 goto error_malloc;
175 }
176
177 /* Define session name */
178 if (name != NULL) {
179 if (snprintf(new_session->name, NAME_MAX, "%s", name) < 0) {
180 ret = LTTCOMM_FATAL;
181 goto error_asprintf;
182 }
183 } else {
184 ERR("No session name given");
185 ret = LTTCOMM_FATAL;
186 goto error;
187 }
188
189 /* Define session system path */
190 if (path != NULL) {
191 if (snprintf(new_session->path, PATH_MAX, "%s", path) < 0) {
192 ret = LTTCOMM_FATAL;
193 goto error_asprintf;
194 }
195 new_session->start_consumer = 1;
196 } else {
197 /* No path indicates that there is no use for a consumer. */
198 new_session->start_consumer = 0;
199 new_session->path[0] = '\0';
200 }
201
202 /* Init kernel session */
203 new_session->kernel_session = NULL;
204 new_session->ust_session = NULL;
205
206 /* Init lock */
207 pthread_mutex_init(&new_session->lock, NULL);
208
209 new_session->uid = uid;
210 new_session->gid = gid;
211
212 /* Mkdir if we have a valid path and length */
213 if (strlen(new_session->path) > 0) {
214 ret = run_as_mkdir_recursive(new_session->path, S_IRWXU | S_IRWXG,
215 new_session->uid, new_session->gid);
216 if (ret < 0) {
217 if (ret != -EEXIST) {
218 ERR("Trace directory creation error");
219 ret = LTTCOMM_CREATE_DIR_FAIL;
220 goto error;
221 }
222 }
223 }
224
225 /* Add new session to the session list */
226 session_lock_list();
227 new_session->id = add_session_list(new_session);
228 session_unlock_list();
229
230 /*
231 * Consumer is let to NULL since the create_session_uri command will set it
232 * up and, if valid, assign it to the session.
233 */
234
235 DBG("Tracing session %s created in %s with ID %u by UID %d GID %d", name,
236 path, new_session->id, new_session->uid, new_session->gid);
237
238 return LTTCOMM_OK;
239
240 error:
241 error_asprintf:
242 if (new_session != NULL) {
243 free(new_session);
244 }
245
246 error_malloc:
247 return ret;
248 }
249
250 /*
251 * Check if the UID or GID match the session. Root user has access to all
252 * sessions.
253 */
254 int session_access_ok(struct ltt_session *session, uid_t uid, gid_t gid)
255 {
256 assert(session);
257
258 if (uid != session->uid && gid != session->gid && uid != 0) {
259 return 0;
260 } else {
261 return 1;
262 }
263 }
This page took 0.049812 seconds and 3 git commands to generate.