Merge branch 'jk/line-log-with-patch'
[git] / trace2 / tr2_dst.c
1 #include "cache.h"
2 #include "trace2/tr2_dst.h"
3
4 /*
5  * If a Trace2 target cannot be opened for writing, we should issue a
6  * warning to stderr, but this is very annoying if the target is a pipe
7  * or socket and beyond the user's control -- especially since every
8  * git command (and sub-command) will print the message.  So we silently
9  * eat these warnings and just discard the trace data.
10  *
11  * Enable the following environment variable to see these warnings.
12  */
13 #define TR2_ENVVAR_DST_DEBUG "GIT_TR2_DST_DEBUG"
14
15 static int tr2_dst_want_warning(void)
16 {
17         static int tr2env_dst_debug = -1;
18
19         if (tr2env_dst_debug == -1) {
20                 const char *env_value = getenv(TR2_ENVVAR_DST_DEBUG);
21                 if (!env_value || !*env_value)
22                         tr2env_dst_debug = 0;
23                 else
24                         tr2env_dst_debug = atoi(env_value) > 0;
25         }
26
27         return tr2env_dst_debug;
28 }
29
30 void tr2_dst_trace_disable(struct tr2_dst *dst)
31 {
32         if (dst->need_close)
33                 close(dst->fd);
34         dst->fd = 0;
35         dst->initialized = 1;
36         dst->need_close = 0;
37 }
38
39 static int tr2_dst_try_path(struct tr2_dst *dst, const char *tgt_value)
40 {
41         int fd = open(tgt_value, O_WRONLY | O_APPEND | O_CREAT, 0666);
42         if (fd == -1) {
43                 if (tr2_dst_want_warning())
44                         warning("trace2: could not open '%s' for '%s' tracing: %s",
45                                 tgt_value, dst->env_var_name, strerror(errno));
46
47                 tr2_dst_trace_disable(dst);
48                 return 0;
49         }
50
51         dst->fd = fd;
52         dst->need_close = 1;
53         dst->initialized = 1;
54
55         return dst->fd;
56 }
57
58 #ifndef NO_UNIX_SOCKETS
59 #define PREFIX_AF_UNIX "af_unix:"
60 #define PREFIX_AF_UNIX_STREAM "af_unix:stream:"
61 #define PREFIX_AF_UNIX_DGRAM "af_unix:dgram:"
62
63 static int tr2_dst_try_uds_connect(const char *path, int sock_type, int *out_fd)
64 {
65         int fd;
66         struct sockaddr_un sa;
67
68         fd = socket(AF_UNIX, sock_type, 0);
69         if (fd == -1)
70                 return errno;
71
72         sa.sun_family = AF_UNIX;
73         strlcpy(sa.sun_path, path, sizeof(sa.sun_path));
74
75         if (connect(fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
76                 int e = errno;
77                 close(fd);
78                 return e;
79         }
80
81         *out_fd = fd;
82         return 0;
83 }
84
85 #define TR2_DST_UDS_TRY_STREAM (1 << 0)
86 #define TR2_DST_UDS_TRY_DGRAM  (1 << 1)
87
88 static int tr2_dst_try_unix_domain_socket(struct tr2_dst *dst,
89                                           const char *tgt_value)
90 {
91         unsigned int uds_try = 0;
92         int fd;
93         int e;
94         const char *path = NULL;
95
96         /*
97          * Allow "af_unix:[<type>:]<absolute_path>"
98          *
99          * Trace2 always writes complete individual messages (without
100          * chunking), so we can talk to either DGRAM or STREAM type sockets.
101          *
102          * Allow the user to explicitly request the socket type.
103          *
104          * If they omit the socket type, try one and then the other.
105          */
106
107         if (skip_prefix(tgt_value, PREFIX_AF_UNIX_STREAM, &path))
108                 uds_try |= TR2_DST_UDS_TRY_STREAM;
109
110         else if (skip_prefix(tgt_value, PREFIX_AF_UNIX_DGRAM, &path))
111                 uds_try |= TR2_DST_UDS_TRY_DGRAM;
112
113         else if (skip_prefix(tgt_value, PREFIX_AF_UNIX, &path))
114                 uds_try |= TR2_DST_UDS_TRY_STREAM | TR2_DST_UDS_TRY_DGRAM;
115
116         if (!path || !*path) {
117                 if (tr2_dst_want_warning())
118                         warning("trace2: invalid AF_UNIX value '%s' for '%s' tracing",
119                                 tgt_value, dst->env_var_name);
120
121                 tr2_dst_trace_disable(dst);
122                 return 0;
123         }
124
125         if (!is_absolute_path(path) ||
126             strlen(path) >= sizeof(((struct sockaddr_un *)0)->sun_path)) {
127                 if (tr2_dst_want_warning())
128                         warning("trace2: invalid AF_UNIX path '%s' for '%s' tracing",
129                                 path, dst->env_var_name);
130
131                 tr2_dst_trace_disable(dst);
132                 return 0;
133         }
134
135         if (uds_try & TR2_DST_UDS_TRY_STREAM) {
136                 e = tr2_dst_try_uds_connect(path, SOCK_STREAM, &fd);
137                 if (!e)
138                         goto connected;
139                 if (e != EPROTOTYPE)
140                         goto error;
141         }
142         if (uds_try & TR2_DST_UDS_TRY_DGRAM) {
143                 e = tr2_dst_try_uds_connect(path, SOCK_DGRAM, &fd);
144                 if (!e)
145                         goto connected;
146         }
147
148 error:
149         if (tr2_dst_want_warning())
150                 warning("trace2: could not connect to socket '%s' for '%s' tracing: %s",
151                         path, dst->env_var_name, strerror(e));
152
153         tr2_dst_trace_disable(dst);
154         return 0;
155
156 connected:
157         dst->fd = fd;
158         dst->need_close = 1;
159         dst->initialized = 1;
160
161         return dst->fd;
162 }
163 #endif
164
165 static void tr2_dst_malformed_warning(struct tr2_dst *dst,
166                                       const char *tgt_value)
167 {
168         struct strbuf buf = STRBUF_INIT;
169
170         strbuf_addf(&buf, "trace2: unknown value for '%s': '%s'",
171                     dst->env_var_name, tgt_value);
172         warning("%s", buf.buf);
173
174         strbuf_release(&buf);
175 }
176
177 int tr2_dst_get_trace_fd(struct tr2_dst *dst)
178 {
179         const char *tgt_value;
180
181         /* don't open twice */
182         if (dst->initialized)
183                 return dst->fd;
184
185         dst->initialized = 1;
186
187         tgt_value = getenv(dst->env_var_name);
188
189         if (!tgt_value || !strcmp(tgt_value, "") || !strcmp(tgt_value, "0") ||
190             !strcasecmp(tgt_value, "false")) {
191                 dst->fd = 0;
192                 return dst->fd;
193         }
194
195         if (!strcmp(tgt_value, "1") || !strcasecmp(tgt_value, "true")) {
196                 dst->fd = STDERR_FILENO;
197                 return dst->fd;
198         }
199
200         if (strlen(tgt_value) == 1 && isdigit(*tgt_value)) {
201                 dst->fd = atoi(tgt_value);
202                 return dst->fd;
203         }
204
205         if (is_absolute_path(tgt_value))
206                 return tr2_dst_try_path(dst, tgt_value);
207
208 #ifndef NO_UNIX_SOCKETS
209         if (starts_with(tgt_value, PREFIX_AF_UNIX))
210                 return tr2_dst_try_unix_domain_socket(dst, tgt_value);
211 #endif
212
213         /* Always warn about malformed values. */
214         tr2_dst_malformed_warning(dst, tgt_value);
215         tr2_dst_trace_disable(dst);
216         return 0;
217 }
218
219 int tr2_dst_trace_want(struct tr2_dst *dst)
220 {
221         return !!tr2_dst_get_trace_fd(dst);
222 }
223
224 void tr2_dst_write_line(struct tr2_dst *dst, struct strbuf *buf_line)
225 {
226         int fd = tr2_dst_get_trace_fd(dst);
227
228         strbuf_complete_line(buf_line); /* ensure final NL on buffer */
229
230         /*
231          * We do not use write_in_full() because we do not want
232          * a short-write to try again.  We are using O_APPEND mode
233          * files and the kernel handles the atomic seek+write. If
234          * another thread or git process is concurrently writing to
235          * this fd or file, our remainder-write may not be contiguous
236          * with our initial write of this message.  And that will
237          * confuse readers.  So just don't bother.
238          *
239          * It is assumed that TRACE2 messages are short enough that
240          * the system can write them in 1 attempt and we won't see
241          * a short-write.
242          *
243          * If we get an IO error, just close the trace dst.
244          */
245         if (write(fd, buf_line->buf, buf_line->len) >= 0)
246                 return;
247
248         if (tr2_dst_want_warning())
249                 warning("unable to write trace to '%s': %s", dst->env_var_name,
250                         strerror(errno));
251         tr2_dst_trace_disable(dst);
252 }