ttrace: enhance -ttrace_vblank option

Change-Id: Ic3afb55d3b7cf06e8962bea0ee0f71322fc06d27

diff --git a/client/tdm_client.c b/client/tdm_client.c
index 267854b..e576c3d 100644 (file)
--- a/client/tdm_client.c
+++ b/client/tdm_client.c
@@ -92,6 +92,7 @@ struct _tdm_private_client_vblank {
        unsigned int fps;
        int offset;
        unsigned int enable_fake;
+       unsigned int enable_ttrace;
 
        unsigned int started;
        unsigned int stamp;
@@ -153,7 +154,8 @@ _tdm_client_vblank_cb_done(void *data, struct wl_tdm_vblank *wl_tdm_vblank,
                if (w->req_id != req_id)
                        continue;
 
-               TDM_TRACE_ASYNC_END((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
+               if (private_vblank->enable_ttrace)
+                       TDM_TRACE_ASYNC_END((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
 
                if (w->req_time >= private_vblank->last_time)
                        TDM_WRN("'req(%.6f) < last(%.6f)' failed", w->req_time, private_vblank->last_time);
@@ -170,9 +172,20 @@ _tdm_client_vblank_cb_done(void *data, struct wl_tdm_vblank *wl_tdm_vblank,
        }
 }
 
+static void
+_tdm_client_vblank_cb_ttrace(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t enable)
+{
+       tdm_private_client_vblank *private_vblank = data;
+
+       TDM_RETURN_IF_FAIL(private_vblank != NULL);
+
+       private_vblank->enable_ttrace = enable;
+}
+
 static const struct wl_tdm_vblank_listener tdm_client_vblank_listener = {
        _tdm_client_vblank_cb_stamp,
        _tdm_client_vblank_cb_done,
+       _tdm_client_vblank_cb_ttrace,
 };
 
 static void
@@ -889,7 +902,8 @@ tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_cli
 
        wl_tdm_vblank_wait_vblank(private_vblank->vblank, interval, w->req_id, req_sec, req_usec);
 
-       TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
+       if (private_vblank->enable_ttrace)
+               TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
 
        TDM_DBG("vblank(%p) interval(%u) req_id(%d) req(%.6f)",
                        vblank, interval, w->req_id, w->req_time);
@@ -973,7 +987,8 @@ tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence,
 
        wl_tdm_vblank_wait_vblank_seq(private_vblank->vblank, sequence, w->req_id, req_sec, req_usec);
 
-       TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
+       if (private_vblank->enable_ttrace)
+               TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
 
        TDM_DBG("vblank(%p) sequence(%u) req_id(%d) req(%.6f)",
                        vblank, sequence, w->req_id, w->req_time);

diff --git a/protocol/tdm.xml b/protocol/tdm.xml
index 0947115..24c603e 100644 (file)
--- a/protocol/tdm.xml
+++ b/protocol/tdm.xml
@@ -86,6 +86,10 @@
             <arg name="error" type="uint" summary="error status enumeration"/>
         </event>
 
+        <event name="ttrace">
+            <arg name="enable" type="uint"/>
+        </event>
+
         <request name="destroy" type="destructor"/>
 
         <request name="set_name">

diff --git a/src/tdm.c b/src/tdm.c
index 53732ac..7c36041 100644 (file)
--- a/src/tdm.c
+++ b/src/tdm.c
@@ -201,6 +201,13 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output)
                _pthread_mutex_lock(&private_display->lock);
        }
 
+       if (private_output->ttrace_vblank) {
+               /* tdm_vblank APIs is for server. it should be called in unlock status*/
+               _pthread_mutex_unlock(&private_display->lock);
+               tdm_vblank_destroy(private_output->ttrace_vblank);
+               _pthread_mutex_lock(&private_display->lock);
+       }
+
        LIST_FOR_EACH_ENTRY_SAFE(c, cc, &private_output->capture_list, link)
        tdm_capture_destroy_internal(c);
 
@@ -1281,14 +1288,13 @@ tdm_display_enable_path(const char *path)
        return TDM_ERROR_NONE;
 }
 
-
 static void
 _tdm_display_ttrace_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
                                                          unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 {
        tdm_error ret = TDM_ERROR_NONE;
 
-       TDM_TRACE_MARK("TDM_DISPLAY_TTRACE_VBlank");
+       TDM_TRACE_MARK("VSYNC");
 
        ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL);
        TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
@@ -1297,42 +1303,50 @@ _tdm_display_ttrace_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int
 INTERN tdm_error
 tdm_display_enable_ttrace_vblank(tdm_display *dpy, tdm_output *output, int enable)
 {
-       static tdm_vblank *vblank = NULL;
+       tdm_private_display *private_display = dpy;
+       tdm_private_output *private_output = NULL;
+       const tdm_output_mode *mode = NULL;
+       tdm_vblank *vblank = NULL;
        tdm_error ret = TDM_ERROR_NONE;
 
        if (!enable) {
-               if (vblank)
-                       tdm_vblank_destroy(vblank);
-               vblank = NULL;
+               LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link) {
+                       if (private_output->ttrace_vblank)
+                               tdm_vblank_destroy(private_output->ttrace_vblank);
+                       private_output->ttrace_vblank = NULL;
+               }
                return TDM_ERROR_NONE;
-       } else {
-               const tdm_output_mode *mode = NULL;
+       }
 
-               if (vblank)
-                       return TDM_ERROR_NONE;
+       private_output = output;
+       TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-               vblank = tdm_vblank_create(dpy, output, &ret);
-               TDM_RETURN_VAL_IF_FAIL(vblank != NULL, ret);
+       if (private_output->ttrace_vblank)
+               return TDM_ERROR_NONE;
 
-               ret = tdm_output_get_mode(output, &mode);
-               TDM_GOTO_IF_FAIL(mode != NULL, enable_fail);
+       vblank = tdm_vblank_create(private_display, output, &ret);
+       TDM_RETURN_VAL_IF_FAIL(vblank != NULL, ret);
 
-               ret = tdm_vblank_set_fps(vblank, mode->vrefresh);
-               TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
+       ret = tdm_output_get_mode(output, &mode);
+       TDM_GOTO_IF_FAIL(mode != NULL, enable_fail);
 
-               ret = tdm_vblank_set_enable_fake(vblank, 1);
-               TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
+       ret = tdm_vblank_set_fps(vblank, mode->vrefresh);
+       TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
 
-               ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL);
-               TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
-       }
+       ret = tdm_vblank_set_enable_fake(vblank, 1);
+       TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
+
+       ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL);
+       TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
+
+       private_output->ttrace_vblank = vblank;
 
        return TDM_ERROR_NONE;
 
 enable_fail:
        if (vblank)
                tdm_vblank_destroy(vblank);
-       vblank = NULL;
+
        return ret;
 }
 

diff --git a/src/tdm_monitor_server.c b/src/tdm_monitor_server.c
index 07c2487..0d92cef 100644 (file)
--- a/src/tdm_monitor_server.c
+++ b/src/tdm_monitor_server.c
@@ -108,12 +108,9 @@ _tdm_monitor_server_dpms(unsigned int pid, char *cwd, int argc, char *argv[], ch
 static void
 _tdm_monitor_server_ttrace_vblank(unsigned int pid, char *cwd, int argc, char *argv[], char *reply, int *len, tdm_display *dpy)
 {
-       int enable, output_id = 0;
-       tdm_output *output;
+       int ttrace_vblank, output_id = 0;
        char *arg;
        char *end;
-       tdm_error ret;
-       tdm_output_type type;
 
        if (argc < 3) {
                _tdm_monitor_server_usage(argv[0], reply, len);
@@ -121,29 +118,45 @@ _tdm_monitor_server_ttrace_vblank(unsigned int pid, char *cwd, int argc, char *a
        }
 
        arg = argv[2];
-       enable = strtol(arg, &end, 10);
+       ttrace_vblank = strtol(arg, &end, 10);
 
-       if (*end == '@') {
-               arg = end + 1;
-               output_id = strtol(arg, &end, 10);
-       }
+       if (ttrace_vblank > 0) {
+               tdm_output *output;
+               tdm_error ret;
+               tdm_output_type type;
+               char *temp;
 
-       output = tdm_display_get_output(dpy, output_id, NULL);
-       if (!output) {
-               TDM_SNPRINTF(reply, len, "can't find the output_id(%d)\n", output_id);
-               return;
-       }
+               if (*end == '@') {
+                       arg = end + 1;
+                       output_id = strtol(arg, &end, 10);
+               }
 
-       ret = tdm_output_get_output_type(output, &type);
-       if (ret != TDM_ERROR_NONE) {
-               TDM_SNPRINTF(reply, len, "can't find the type of output_id(%d)\n", output_id);
-               return;
-       }
+               output = tdm_display_get_output(dpy, output_id, NULL);
+               if (!output) {
+                       TDM_SNPRINTF(reply, len, "can't find the output_id(%d)\n", output_id);
+                       return;
+               }
 
-       tdm_display_enable_ttrace_vblank(dpy, output, enable);
+               ret = tdm_output_get_output_type(output, &type);
+               if (ret != TDM_ERROR_NONE) {
+                       TDM_SNPRINTF(reply, len, "can't find the type of output_id(%d)\n", output_id);
+                       return;
+               }
 
-       TDM_SNPRINTF(reply, len, "%s ttrace vblank for '%s'\n",
-                                (enable) ? "enable" : "disable", tdm_conn_str(type));
+               temp = "server";
+               tdm_display_enable_ttrace_vblank(dpy, output, 1);
+
+               if (ttrace_vblank > 1) {
+                       temp = "clients";
+                       tdm_server_enable_ttrace_vblank(dpy, output, 1);
+               }
+
+               TDM_SNPRINTF(reply, len, "enable ttrace vblank for '%s': %s \n", tdm_conn_str(type), temp);
+       } else {
+               tdm_display_enable_ttrace_vblank(dpy, NULL, 0);
+               tdm_server_enable_ttrace_vblank(dpy, NULL, 0);
+               TDM_SNPRINTF(reply, len, "disable ttrace vblank\n");
+       }
 }
 
 static void
@@ -534,8 +547,8 @@ static struct {
        },
        {
                "ttrace_vblank", _tdm_monitor_server_ttrace_vblank,
-               "enable/disable the vblank for ttrace [0:disable 1:enable]",
-               "<enable>[@<output_idx>]", "0 or 1"
+               "enable/disable the vblank for ttrace [0:disable, 1:server, 2:clients]",
+               "<enable>[@<output_idx>]", "0 or 1 or 2 or 1@0 or 2@0 or 1@1 or 2@1"
        },
        {
                "debug", _tdm_monitor_server_debug,

diff --git a/src/tdm_private.h b/src/tdm_private.h
index 92bb4a1..5e63e5c 100644 (file)
--- a/src/tdm_private.h
+++ b/src/tdm_private.h
@@ -235,6 +235,10 @@ struct _tdm_private_output {
        /* calling a output commit per a vblank */
        int commit_per_vblank;
        tdm_commit_type commit_type;
+
+       /* for ttrace vblank */
+       tdm_vblank *ttrace_vblank;
+       unsigned int ttrace_vblank_client;
 };
 
 struct _tdm_private_layer {
@@ -653,6 +657,8 @@ void
 tdm_server_deinit(tdm_private_loop *private_loop);
 const char*
 tdm_server_get_client_name(pid_t pid);
+tdm_error
+tdm_server_enable_ttrace_vblank(tdm_display *dpy, tdm_output *output, int enable);
 
 char *
 tdm_helper_dump_make_directory(const char *path, char *reply, int *len);

diff --git a/src/tdm_server.c b/src/tdm_server.c
index b11911d..f56b1ad 100644 (file)
--- a/src/tdm_server.c
+++ b/src/tdm_server.c
@@ -88,6 +88,7 @@ typedef struct _tdm_server_client_info {
        pid_t pid;
        char name[TDM_NAME_LEN];
        struct wl_resource *resource;
+       tdm_private_server *private_server;
 } tdm_server_client_info;
 
 static tdm_private_server *keep_private_server;
@@ -167,6 +168,7 @@ _tdm_server_send_done(tdm_server_wait_info *wait_info, tdm_error error,
 {
        tdm_server_wait_info *found;
        tdm_server_vblank_info *vblank_info;
+       tdm_private_output *private_output;
 
        if (!keep_private_server)
                return;
@@ -185,7 +187,9 @@ _tdm_server_send_done(tdm_server_wait_info *wait_info, tdm_error error,
        wl_tdm_vblank_send_done(vblank_info->resource, wait_info->req_id,
                                                        sequence, tv_sec, tv_usec, error);
 
-       TDM_TRACE_ASYNC_END((int)wait_info->req_time, "TDM_Server_Vblank:%u", vblank_info->stamp);
+       private_output = vblank_info->output_info->output;
+       if (private_output->ttrace_vblank_client)
+               TDM_TRACE_ASYNC_END((int)wait_info->req_time, "TDM_Server_Vblank:%u", vblank_info->stamp);
 
        destroy_wait(wait_info);
 }
@@ -304,6 +308,7 @@ _tdm_server_vblank_cb_wait_vblank(struct wl_client *client, struct wl_resource *
        tdm_server_vblank_info *vblank_info = wl_resource_get_user_data(resource);
        tdm_server_output_info *output_info = vblank_info->output_info;
        tdm_private_server *private_server = output_info->private_server;
+       tdm_private_output *private_output = output_info->output;
        tdm_server_wait_info *wait_info;
        unsigned int enable_fake = 0;
        tdm_error ret;
@@ -323,7 +328,9 @@ _tdm_server_vblank_cb_wait_vblank(struct wl_client *client, struct wl_resource *
        if (tdm_debug_module & TDM_DEBUG_VBLANK)
                TDM_DBG("req_id(%d) wait", req_id);
 
-       TDM_TRACE_ASYNC_BEGIN((int)wait_info->req_time, "TDM_Server_Vblank:%u", vblank_info->stamp);
+       private_output = vblank_info->output_info->output;
+       if (private_output->ttrace_vblank_client)
+               TDM_TRACE_ASYNC_BEGIN((int)wait_info->req_time, "TDM_Server_Vblank:%u", vblank_info->stamp);
 
        ret = tdm_vblank_wait(vblank_info->vblank, req_sec, req_usec, interval, _tdm_server_cb_vblank, wait_info);
 
@@ -347,6 +354,7 @@ _tdm_server_vblank_cb_wait_vblank_seq(struct wl_client *client, struct wl_resour
        tdm_server_vblank_info *vblank_info = wl_resource_get_user_data(resource);
        tdm_server_output_info *output_info = vblank_info->output_info;
        tdm_private_server *private_server = output_info->private_server;
+       tdm_private_output *private_output = output_info->output;
        tdm_server_wait_info *wait_info;
        unsigned int enable_fake = 0;
        tdm_error ret;
@@ -366,7 +374,9 @@ _tdm_server_vblank_cb_wait_vblank_seq(struct wl_client *client, struct wl_resour
        if (tdm_debug_module & TDM_DEBUG_VBLANK)
                TDM_DBG("req_id(%d) wait", req_id);
 
-       TDM_TRACE_ASYNC_BEGIN((int)wait_info->req_time, "TDM_Server_Vblank:%u", vblank_info->stamp);
+       private_output = vblank_info->output_info->output;
+       if (private_output->ttrace_vblank_client)
+               TDM_TRACE_ASYNC_BEGIN((int)wait_info->req_time, "TDM_Server_Vblank:%u", vblank_info->stamp);
 
        ret = tdm_vblank_wait_seq(vblank_info->vblank, req_sec, req_usec, sequence, _tdm_server_cb_vblank, wait_info);
 
@@ -735,6 +745,7 @@ _tdm_server_bind(struct wl_client *client, void *data,
        }
 
        cinfo->resource = resource;
+       cinfo->private_server = data;
 
        LIST_ADDTAIL(&cinfo->link, &client_list);
        wl_client_get_credentials(client, &cinfo->pid, NULL, NULL);
@@ -928,3 +939,30 @@ tdm_server_get_client_name(pid_t pid)
 
        return NULL;
 }
+
+INTERN tdm_error
+tdm_server_enable_ttrace_vblank(tdm_display *dpy, tdm_output *output, int enable)
+{
+       tdm_server_client_info *cinfo = NULL;
+
+       LIST_FOR_EACH_ENTRY(cinfo, &client_list, link) {
+               tdm_private_server *private_server = cinfo->private_server;
+               tdm_server_output_info *output_info = NULL;
+
+               LIST_FOR_EACH_ENTRY(output_info, &private_server->output_list, link) {
+                       tdm_server_vblank_info *vblank_info = NULL;
+                       tdm_private_output *private_output = output_info->output;
+
+                       if (output && output_info->output != output)
+                               continue;
+
+                       private_output->ttrace_vblank_client = enable;
+
+                       LIST_FOR_EACH_ENTRY(vblank_info, &output_info->vblank_list, link) {
+                               wl_tdm_vblank_send_ttrace(vblank_info->resource, enable);
+                       }
+               }
+       }
+
+       return TDM_ERROR_NONE;
+}

diff --git a/src/tdm_vblank.c b/src/tdm_vblank.c
index 1a3f6b9..462eaf5 100644 (file)
--- a/src/tdm_vblank.c
+++ b/src/tdm_vblank.c
@@ -771,8 +771,6 @@ _tdm_vblank_cb_vblank_HW(tdm_output *output, unsigned int sequence,
                return;
        }
 
-       TDM_TRACE_ASYNC_END((int)wait_info->req_time, "TDM_HW_Vblank:%u", (unsigned int)private_vblank->stamp);
-
        if (wait_info->type == VBLANK_TYPE_HW_SW) {
                tdm_error ret;
 
@@ -883,8 +881,6 @@ _tdm_vblank_wait_HW(tdm_vblank_wait_info *wait_info)
                                skip, hw_interval, wait_info->target_seq);
        }
 
-       TDM_TRACE_ASYNC_BEGIN((int)wait_info->req_time, "TDM_HW_Vblank:%u", (unsigned int)private_vblank->stamp);
-
        if (private_vblank->add_front)
                ret = tdm_output_wait_vblank_add_front(private_vblank->output, hw_interval, 0,
                                                                                           _tdm_vblank_cb_vblank_HW, wait_info);