]> git.cworth.org Git - vogl/blob - src/vogltrace/vogl_remote.cpp
- regression test now works on AMD
[vogl] / src / vogltrace / vogl_remote.cpp
1 /**************************************************************************
2  *
3  * Copyright 2013-2014 RAD Game Tools and Valve Software
4  * All Rights Reserved.
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  *
24  **************************************************************************/
25
26 #if VOGL_REMOTING
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <unistd.h>
30 #include <errno.h>
31 #include <string.h>
32 #include <sys/types.h>
33 #include <sys/stat.h>
34 #include <signal.h>
35 #include <time.h>
36
37 #include <pthread.h>
38
39 #include <vogl_core.h>
40 #include <vogl_json.h> 
41
42 #include "vogl_intercept.h"
43
44 #include "../common/vogllogging.h"
45 #include "../common/channel.h"
46
47 #include "../common/commands.h"
48 #include "../common/toclientmsg.h"
49 #include "../common/pinggame.h"
50
51
52 // Needs to be the same in the server gpusession code
53 int g_vogl_traceport = TRACE_PORT;
54 char g_procname[256] = { 0 };
55
56 void *invoke_listener(void *arg);
57
58 bool log_output_func(vogl::eConsoleMessageType type, const char *pMsg, void * /*pData*/);
59 void send_status_to_client(const char *message);
60 void send_status_to_client(const char *message, int token);
61
62 void vogl_init_listener(int vogl_traceport)
63 {
64     pthread_t threadCmd;
65     int err = 0;
66
67     openlog("vogl-remote", LOG_PID | LOG_CONS | LOG_PERROR, LOG_USER);
68
69     //
70     //  Get the process name  
71     //    If, in the unlikely event, the name of the process doesn't fit, then readlink won't 0-terminate the string.
72     //    We initialize it to all 0, so if it all got overwritten, then 0 out the last character in the string.
73     //
74     (void) readlink("/proc/self/exe", g_procname, sizeof(g_procname));
75     g_procname[sizeof(g_procname)-1] = '\0';
76
77     
78
79     //  Launching a VOGL Listener
80     if (0 == vogl_traceport)
81     {
82         vogl_traceport = TRACE_PORT;
83         syslog(VOGL_INFO, "No port # passed in, %s listening on default port %d\n", g_procname, vogl_traceport);
84     }
85
86     syslog(VOGL_INFO, "Spinning up listener for vogl_remoting of %s on port %d...\n", g_procname, vogl_traceport);
87
88     g_vogl_traceport = vogl_traceport;
89
90     err = pthread_create(&threadCmd, NULL, invoke_listener, NULL);
91     if (0 != err)
92     {
93         syslog(VOGL_ERROR, "%s:%d %s  Unable to create vogl_remoting cmd thread. returned %d, errno %d\n", __FILE__, __LINE__, __func__, err, errno);
94         return;
95     }
96
97     err = pthread_setname_np(threadCmd, "vogl_remoting");
98     if (0 != err)
99     {
100         syslog(VOGL_ERROR, "%s:%d %s  Unable to set the name of the vogl_remoting cmd thread. returned %d, errno %d\n", __FILE__, __LINE__, __func__, err, errno);
101         return;
102     }
103
104     return;
105 }
106
107 void process_trace_command(void *callback_param, unsigned int buffer_size, char *buffer);
108
109 bool g_fKillApp = false;
110 network::channelmgr *g_clientChannelMgr = NULL;
111
112 void *
113 invoke_listener(void * /*arg*/) 
114 {
115     //
116     //  Setup to wait for a client to connect
117     //
118     pthread_t thisThread = pthread_self();
119     network::CHEC chec = network::EC_NONE;
120
121     int err = 0;
122
123     err = pthread_setname_np(thisThread, "vogl_listen");
124     if (0 != err)
125     {
126         syslog(VOGL_ERROR, "%s:%d %s Unable to set the name of the thread. returned %d, errno %d\n", __FILE__, __LINE__, __func__, err, errno);
127     }
128
129     syslog(VOGL_INFO, "Listener for VOGL Tracing in operation...\n");
130
131     g_clientChannelMgr = new network::channelmgr();
132     if (NULL == g_clientChannelMgr)
133     {
134         syslog(VOGL_ERROR, "%s:%d %s Unable to allocation networking channelmgr.  OOM?\n", __FILE__, __LINE__, __func__);
135         return NULL;
136     }
137
138     //  Create a client channel
139     chec = g_clientChannelMgr->Connect( const_cast<char *>("localhost"), g_vogl_traceport, (SENDASYNC|RECVASYNC), process_trace_command, NULL );
140     //chec = g_clientChannelMgr->Accept( g_vogl_traceport, (RECVASYNC|SENDASYNC), true,  process_trace_command, NULL, NULL, NULL );
141     if (network::EC_NONE != chec)
142     {
143         syslog(VOGL_ERROR, "%s:%d %s Unable to connect on port %d\nExiting.\n", __FILE__, __LINE__, __func__, g_vogl_traceport);
144         return NULL;
145     }
146
147     //
148     //  Tell the client we're up and running.
149     send_status_to_client("Game is up and running.");
150
151     //
152     //  Start capturing output from the tracer
153     vogl::console::add_console_output_func(log_output_func, NULL);
154
155     while (true)
156     {
157         if (g_fKillApp)
158         {
159             break;
160         }
161         sleep(1);  //  Don't busy spin...
162     }
163
164     if (g_fKillApp)
165     {
166         syslog(VOGL_INFO, "%lx: VOGL Tracing server thread: Terminating the application.\n", thisThread);
167         kill(getpid(), SIGTERM); // SIGINT);
168     }
169
170     syslog(VOGL_INFO, "%lx: VOGL Tracing server thread: Terminating.\n", thisThread);
171
172     return NULL;
173 }
174
175 bool SetNullMode(unsigned int buffer_size, char *buffer);
176 bool SetDumpGLCalls(unsigned int buffer_size, char *buffer);
177 bool SetDumpGLBuffers(unsigned int buffer_size, char *buffer);
178 bool SetDumpGLShaders(unsigned int buffer_size, char *buffer);
179 bool SetBackTrace(unsigned int buffer_size, char *buffer);
180
181 bool KillTracer(unsigned int buffer_size, char *buffer);
182 int StartCapture(unsigned int buffer_size, char *buffer);
183 int StopCapture(unsigned int buffer_size, char *buffer);
184
185 extern bool g_null_mode;
186 extern bool g_backtrace_all_calls;
187 extern bool g_dump_gl_calls_flag;
188 extern bool g_dump_gl_buffers_flag;
189 extern bool g_dump_gl_shaders_flag;
190
191 //  Async calls to send contents to our client
192 //
193 void CaptureCompleteCallback(const char *pFilename, void *pOpaque);
194
195
196 void process_trace_command(void * /*callback_param*/, unsigned int buffer_size, char *buffer)
197 {
198     int err = 0;
199     int32_t command = -1;
200
201     command = *(int32_t *)buffer;
202
203     unsigned int buffer_size_temp = buffer_size - sizeof(int32_t);
204     char *buffer_temp = buffer + sizeof(int32_t);
205
206     switch (command)
207     {
208         case TRACE_SETNULLMODE:
209         {
210             g_null_mode = SetNullMode(buffer_size_temp, buffer_temp);
211
212             break;
213         }
214
215         case TRACE_SETDUMPGLCALLS:
216         {
217             g_dump_gl_calls_flag = SetDumpGLCalls(buffer_size_temp, buffer_temp);
218
219             break;
220         }
221
222         case TRACE_SETDUMPGLBUFFERS:
223         {
224             g_dump_gl_buffers_flag = SetDumpGLBuffers(buffer_size_temp, buffer_temp);
225
226             break;
227         }
228
229         case TRACE_SETDUMPGLSHADERS:
230         {
231             g_dump_gl_shaders_flag = SetDumpGLShaders(buffer_size_temp, buffer_temp);
232
233             break;
234         }
235
236         case TRACE_SETBACKTRACE:
237         {
238             g_backtrace_all_calls = SetBackTrace(buffer_size_temp, buffer_temp);
239
240             break;
241         }
242
243         case TRACE_KILLTRACER:
244         {
245             g_fKillApp = KillTracer(buffer_size_temp, buffer_temp);
246
247             break;
248         }
249
250         case TRACE_STARTCAPTURE:
251         {
252
253             err = StartCapture(buffer_size_temp, buffer_temp);
254
255             if (0 != err)
256             {
257                 syslog(VOGL_ERROR, "%s:%d %s  StartCapture() failed\n", __FILE__, __LINE__, __func__);
258             }
259
260             break;
261         }
262
263         case TRACE_STOPCAPTURE:
264         {
265
266             err = StopCapture(buffer_size_temp, buffer_temp);
267
268             if (0 != err)
269             {
270                 syslog(VOGL_ERROR, "%s:%d %s  StopCapture() failed\n", __FILE__, __LINE__, __func__);
271             }
272
273             break;
274         }
275
276         case PING_GAME:
277         {
278             int notif_id = -1;
279             notif_id = PingGame(buffer_size_temp, buffer_temp);
280             //
281             //  Tell the client we're up and running.
282             send_status_to_client("Game is up and running.", notif_id);
283
284             break;
285         }
286
287         default:
288         {
289             syslog(VOGL_ERROR, "%s:%d %s  Unknown method (%d)\n", __FILE__, __LINE__, __func__, command);
290             break;
291         }
292     }
293
294     return;
295 }
296
297 //
298 //  SetNullModePB
299 //
300 bool SetNullMode(unsigned int buffer_size, char *buffer)
301 {
302     vogl::json_document cur_doc;
303
304     if (0 == buffer_size)
305         return false;
306
307     cur_doc.deserialize(buffer);
308     vogl::json_node *pjson_node = cur_doc.get_root()->find_child_object("parameters");
309
310     return pjson_node->value_as_bool("nullmode", false);
311 }
312
313 //
314 //  SetDumpGLCallsPB
315 //
316 bool SetDumpGLCalls(unsigned int buffer_size, char *buffer)
317 {
318     vogl::json_document cur_doc;
319
320     if (0 == buffer_size)
321         return false;
322
323     cur_doc.deserialize(buffer);
324     vogl::json_node *pjson_node = cur_doc.get_root()->find_child_object("parameters");
325
326     return pjson_node->value_as_bool("dumpglcalls", false);
327 }
328
329 //
330 //  SetDumpGLBuffersPB
331 //
332 //
333 bool SetDumpGLBuffers(unsigned int buffer_size, char *buffer)
334 {
335     vogl::json_document cur_doc;
336
337     if (0 == buffer_size)
338         return false;
339
340     cur_doc.deserialize(buffer);
341     vogl::json_node *pjson_node = cur_doc.get_root()->find_child_object("parameters");
342
343     return pjson_node->value_as_bool("dumpglbuffers", false);
344 }
345
346 //
347 //  SetDumpGLShaders
348 //
349 //
350 bool SetDumpGLShaders(unsigned int buffer_size, char *buffer)
351 {
352     vogl::json_document cur_doc;
353
354     if (0 == buffer_size)
355         return false;
356
357     cur_doc.deserialize(buffer);
358     vogl::json_node *pjson_node = cur_doc.get_root()->find_child_object("parameters");
359
360     return pjson_node->value_as_bool("dumpglshaders", false);
361 }
362
363 //
364 //  SetBackTrace
365 //
366 //  Parameters:
367 //    If turned on, captures callstacks for any GL call and put it in the tracefile.
368 //
369 bool SetBackTrace(unsigned int buffer_size, char *buffer)
370 {
371     vogl::json_document cur_doc;
372
373     if (0 == buffer_size)
374         return false;
375
376     cur_doc.deserialize(buffer);
377     vogl::json_node *pjson_node = cur_doc.get_root()->find_child_object("parameters");
378
379     return pjson_node->value_as_bool("backtrace", false);
380 }
381
382 //
383 //  KillTracer
384 //
385 //  Kills the application that is currently being traced.
386 //
387 bool KillTracer(unsigned int /*buffer_size*/, char * /*buffer*/)
388 {
389     // No body to this message.  Just an instruction.
390     return true;
391 }
392
393
394 char szTraceFileLocal[] = "/.local/share";
395
396 int StartCapture(unsigned int buffer_size, char *buffer)
397 {
398     const char *szBaseFileName;
399     int cFrames = 0;
400     bool fWorked = true;
401     vogl::json_document cur_doc;
402     vogl::json_node *pjson_node;
403     int status = 0;
404
405     std::string strTraceLocation;
406     char *szTraceLocationT = NULL;
407
408     syslog(VOGL_INFO, "Checking to see if we're already capturing\n");
409
410     if (vogl_is_capturing())
411     {
412         goto out;
413     }
414
415     if (0 == buffer_size)
416     {
417         syslog(VOGL_ERROR, "%s:%d %s  No parameters passed\n", __FILE__, __LINE__, __func__);
418         goto out;
419     }
420
421     cur_doc.deserialize(buffer);
422     pjson_node = cur_doc.get_root()->find_child_object("parameters");
423     
424     syslog(VOGL_INFO, "Not already capturing...continuing\n");
425
426     cFrames = pjson_node->value_as_int("framestocapture", -1);
427     szBaseFileName = pjson_node->value_as_string_ptr("tracename", "");
428
429     syslog(VOGL_INFO, "Capturing to %s for %d frames\n", szBaseFileName, cFrames);
430
431
432     //
433     //  Handle the destination directory for the file as per spec
434     //    $XDG_DATA_HOME defines the base directory relative to which user specific data files should be stored. 
435     //    If $XDG_DATA_HOME is either not set or empty, a default equal to $HOME/.local/share should be used.
436     szTraceLocationT = getenv("XDG_DATA_HOME");
437     syslog(VOGL_INFO, "XDG_DATA_HOME is '%s'\n", (NULL == szTraceLocationT? "NULL": szTraceLocationT));
438     if (NULL == szTraceLocationT)
439     {
440         syslog(VOGL_INFO, "Building strTraceLocation from '%s' + '%s'\n", getenv("HOME"), szTraceFileLocal);
441         strTraceLocation = getenv("HOME");
442         strTraceLocation += szTraceFileLocal;
443     }
444     else
445     {
446         strTraceLocation = szTraceLocationT;
447     }
448     strTraceLocation += "/vogl/";
449
450     syslog(VOGL_INFO, "Will be tracing to '%s'\n", strTraceLocation.c_str());
451
452     //  Ensure the destination directory is actually there
453     status = mkdir(strTraceLocation.c_str(), 0777 );
454     if (-1 == status && EEXIST != errno)
455     {
456         syslog(VOGL_INFO, "StartCapturePB: Unable to create trace destination directory (%d) %s\n", errno, strTraceLocation.c_str());
457
458         return -1;
459     }
460
461     syslog(VOGL_INFO, "StartCapturePB: Capturing trace to %s%s for %d frames\n", strTraceLocation.c_str(), szBaseFileName, cFrames);
462
463     fWorked = vogl_capture_on_next_swap(cFrames, strTraceLocation.c_str(), szBaseFileName, CaptureCompleteCallback, NULL);
464
465     syslog(VOGL_INFO, "StartCapturePB: Tracing now started (%s).  Trace Basefilename = %s\n", (fWorked ? "success" : "failed"), szBaseFileName);
466
467 out:
468
469     return 0;
470 }
471
472
473 int StopCapture(unsigned int /*buffer_size*/, char * /*buffer*/)
474 {
475     bool fStillCapturing = false;
476     bool fStopping = false;
477
478     //
479     //  No body to this message.  Not necessary.
480
481     fStillCapturing = vogl_is_capturing();
482     syslog(VOGL_INFO, "StopCapturePB(): Trace status = %d\n", fStillCapturing);
483
484     if (true == fStillCapturing)
485     {
486         //  Need to terminate the trace
487         fStopping = vogl_stop_capturing(CaptureCompleteCallback, NULL);
488         syslog(VOGL_INFO, "StopCapturePB(): vogl_stop_capturing status = %d\n", fStopping);
489     }
490
491     return 0;
492 }
493
494
495 //
496 //  Sends off a message to the client that tracing has completed.
497 //
498 int CaptureCompleteCallbackMsg(const char *pFilename, int cFramesCaptured, unsigned int *message_size, char **pmessage);
499 void CaptureCompleteCallback(const char *pFilename, void * /*pOpaque*/)
500 {
501     int ec = 0;
502     network::CHEC chec = network::EC_NONE;
503     char *message = NULL;
504     unsigned int message_size = 0;
505     int cFramesCaptured = -1;
506
507     syslog(VOGL_INFO, "CaptureCompleteCallback(): Tracing complete...\n");
508
509     //  Send off a status message to the client with:
510     //  process_name
511     //  file_name
512     //  frames_capture (TBD)
513     //  Anything else?
514     ec = CaptureCompleteCallbackMsg(pFilename, cFramesCaptured, &message_size, &message);
515     if (0 != ec)
516     {
517         syslog(VOGL_ERROR, "%s:%d %s  Unable to send tracefile name (%s) back to client - OOM?\n", __FILE__, __LINE__, __func__, pFilename);
518         return;       
519     }
520
521     chec = g_clientChannelMgr->SendData(message_size, message);
522     if (network::EC_NONE != chec)
523     {
524         syslog(VOGL_ERROR, "%s:%d %s  Unable to send tracefile name (%s) back to client - Network error.\n", __FILE__, __LINE__, __func__, pFilename);
525     }
526
527     if (message)
528         free(message);
529
530     return;
531 }
532
533
534 int CaptureCompleteCallbackMsg(const char *pFilename, int cFramesCaptured, unsigned int *message_size, char **pmessage)
535 {
536     vogl::json_document cur_doc;
537     vogl::dynamic_string dst;
538
539     char *pbBuff;
540     unsigned int cbBuff;
541
542     vogl::json_node &meta_node = cur_doc.get_root()->add_object("parameters");
543
544     meta_node.add_key_value("trace_file_name", pFilename);
545     meta_node.add_key_value("process_name", g_procname);
546     meta_node.add_key_value("frames_captured", cFramesCaptured);
547
548     cur_doc.serialize(dst);
549
550     cbBuff = dst.get_len() + 1 + sizeof(int);
551     pbBuff = (char *)malloc(cbBuff);
552     if (NULL == pbBuff)
553     {
554         printf("OOM\n");
555         return -1;
556     }
557
558     //  First part of buffer is the command id
559     *((int *)pbBuff) = TRACE_CAPTURESTATUS;
560     strncpy((char *)(pbBuff+sizeof(int)), dst.get_ptr(), cbBuff - sizeof(int));
561
562     *pmessage = pbBuff;
563     *message_size = cbBuff;
564
565     return 0;
566 }
567
568
569 bool log_output_func(vogl::eConsoleMessageType /*type*/, const char *pMsg, void * /*pData*/)
570 {
571
572     send_status_to_client(pMsg);
573
574     return true;
575 }
576
577
578 void send_status_to_client(const char *message)
579 {
580     int ec = 0;
581     unsigned int cbBuff = 0;
582     char *pbBuff = NULL;
583     //
584     //  Prepare message to send
585
586     ec = ToClientMsgReq(g_procname, 0, message, &cbBuff, &pbBuff);
587
588     (void)g_clientChannelMgr->SendData(cbBuff, pbBuff);
589
590     if (pbBuff)
591         free(pbBuff);
592
593     return;
594 }
595
596 void send_status_to_client(const char *message, int /*token*/)
597 {
598     //  Ignoring token for a moment.
599     send_status_to_client(message);
600
601     return;
602 }
603
604 #endif // VOGL_REMOTING