Bump up version 1.0.8

sync code spin tizen_2.4

Change-Id: I16362f9848d8edfaef72b99e1cb6ce1e5d3dc452

diff --git a/packaging/libtbm-exynos4412.spec b/packaging/libtbm-exynos4412.spec
index 924aec4..c148012 100644 (file)
--- a/packaging/libtbm-exynos4412.spec
+++ b/packaging/libtbm-exynos4412.spec
@@ -1,5 +1,5 @@
 Name:           libtbm-exynos4412
-Version:        1.0.6
+Version:        1.0.8
 Release:        1
 License:        MIT
 Summary:        Tizen Buffer Manager - exynos4412 backend

diff --git a/src/tbm_bufmgr_exynos4412.c b/src/tbm_bufmgr_exynos4412.c
index 0f90ffd..354e1a9 100755 (executable)
--- a/src/tbm_bufmgr_exynos4412.c
+++ b/src/tbm_bufmgr_exynos4412.c
@@ -97,8 +97,8 @@ char* target_name()
 
     return app_name;
 }
-#define TBM_EXYNOS4412_LOG(fmt, args...)               LOGE("\033[31m"  "[%s]" fmt "\033[0m", target_name(), ##args)
-#define DBG(fmt, args...)              if(bDebug&01) LOGE("[%s]" fmt, target_name(), ##args)
+#define TBM_EXYNOS4412_LOG(fmt, args...) LOGE("\033[31m"  "[%s]" fmt "\033[0m", target_name(), ##args)
+#define DBG(fmt, args...)  if(bDebug&01) LOGE(fmt, ##args)
 #else
 #define TBM_EXYNOS4412_LOG(...)
 #define DBG(...)
@@ -270,9 +270,8 @@ _get_name (int fd, unsigned int gem)
     arg.handle = gem;
     if (drmIoctl (fd, DRM_IOCTL_GEM_FLINK, &arg))
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                 "error %s:%d fail to get flink gem=%d\n",
-                 getpid(), __FUNCTION__, __LINE__, gem);
+        TBM_EXYNOS4412_LOG ("error fail to get flink from gem:%d (DRM_IOCTL_GEM_FLINK)\n",
+                gem);
         return 0;
     }
 
@@ -300,24 +299,19 @@ _exynos4412_bo_handle (tbm_bo_exynos4412 bo_exynos4412, int device)
             arg.handle = bo_exynos4412->gem;
             if (drmIoctl (bo_exynos4412->fd, DRM_IOCTL_MODE_MAP_DUMB, &arg))
             {
-                TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                         "error %s:%d Cannot map_dumb gem=%d\n",
-                         getpid(), __FUNCTION__, __LINE__, bo_exynos4412->gem);
-                return (tbm_bo_handle) NULL;
+               TBM_EXYNOS4412_LOG ("error Cannot map_dumb gem=%d\n", bo_exynos4412->gem);
+               return (tbm_bo_handle) NULL;
             }
 
             map = mmap (NULL, bo_exynos4412->size, PROT_READ|PROT_WRITE, MAP_SHARED,
                               bo_exynos4412->fd, arg.offset);
             if (map == MAP_FAILED)
             {
-                TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                         "error %s:%d Cannot usrptr gem=%d\n",
-                         getpid(), __FUNCTION__, __LINE__, bo_exynos4412->gem);
+                TBM_EXYNOS4412_LOG ("error Cannot usrptr gem=%d\n", bo_exynos4412->gem);
                 return (tbm_bo_handle) NULL;
             }
             bo_exynos4412->pBase = map;
         }
-
         bo_handle.ptr = (void *)bo_exynos4412->pBase;
         break;
     case TBM_DEVICE_3D:
@@ -335,9 +329,7 @@ _exynos4412_bo_handle (tbm_bo_exynos4412 bo_exynos4412, int device)
             arg.handle = bo_exynos4412->gem;
             if (drmIoctl (bo_exynos4412->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &arg))
             {
-                TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                         "error %s:%d Cannot dmabuf=%d\n",
-                         getpid(), __FUNCTION__, __LINE__, bo_exynos4412->gem);
+                TBM_EXYNOS4412_LOG ("error Cannot dmabuf=%d\n", bo_exynos4412->gem);
                 return (tbm_bo_handle) NULL;
             }
             bo_exynos4412->dmabuf = arg.fd;
@@ -354,9 +346,7 @@ _exynos4412_bo_handle (tbm_bo_exynos4412 bo_exynos4412, int device)
             arg.handle = bo_exynos4412->gem;
             if (drmIoctl (bo_exynos4412->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &arg))
             {
-                TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                         "error %s:%d Cannot dmabuf=%d\n",
-                         getpid(), __FUNCTION__, __LINE__, bo_exynos4412->gem);
+                TBM_EXYNOS4412_LOG ("error Cannot dmabuf=%d\n", bo_exynos4412->gem);
                 return (tbm_bo_handle) NULL;
             }
             bo_exynos4412->dmabuf = arg.fd;
@@ -365,9 +355,7 @@ _exynos4412_bo_handle (tbm_bo_exynos4412 bo_exynos4412, int device)
         bo_handle.u32 = (uint32_t)bo_exynos4412->dmabuf;
         break;
     default:
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                 "error %s:%d Not supported device:%d\n",
-                 getpid(), __FUNCTION__, __LINE__, device);
+        TBM_EXYNOS4412_LOG ("error Not supported device:%d\n", device);
         bo_handle.ptr = (void *) NULL;
         break;
     }
@@ -419,15 +407,11 @@ _exynos4412_cache_flush (int fd, tbm_bo_exynos4412 bo_exynos4412, int flags)
     ret = drmCommandWriteRead (fd, DRM_EXYNOS_GEM_CACHE_OP, &cache_op, sizeof(cache_op));
     if (ret)
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                 "error %s:%d fail to flush the cache.\n",
-                 getpid(), __FUNCTION__, __LINE__);
+        TBM_EXYNOS4412_LOG ("error fail to flush the cache.\n");
         return 0;
     }
 #else
-    TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-             "warning %s:%d fail to enable the cache flush.\n",
-             getpid(), __FUNCTION__, __LINE__);
+    TBM_EXYNOS4412_LOG ("warning fail to enable the cache flush.\n");
 #endif
     return 1;
 }
@@ -459,9 +443,7 @@ tbm_exynos4412_bo_alloc (tbm_bo bo, int size, int flags)
     bo_exynos4412 = calloc (1, sizeof(struct _tbm_bo_exynos4412));
     if (!bo_exynos4412)
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                 "error %s:%d fail to allocate the bo private\n",
-                 getpid(), __FUNCTION__, __LINE__);
+        TBM_EXYNOS4412_LOG ("error fail to allocate the bo private\n");
         return 0;
     }
 
@@ -477,9 +459,7 @@ tbm_exynos4412_bo_alloc (tbm_bo bo, int size, int flags)
     arg.flags = exynos_flags;
     if (drmCommandWriteRead(bufmgr_exynos4412->fd, DRM_EXYNOS_GEM_CREATE, &arg, sizeof(arg)))
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                 "error %s:%d Cannot create bo(flag:%x, size:%d)\n",
-                 getpid(), __FUNCTION__, __LINE__, arg.flags, (unsigned int)arg.size);
+        TBM_EXYNOS4412_LOG ("error Cannot create bo(flag:%x, size:%d)\n", arg.flags, (unsigned int)arg.size);
         free (bo_exynos4412);
         return 0;
     }
@@ -501,9 +481,7 @@ tbm_exynos4412_bo_alloc (tbm_bo bo, int size, int flags)
         arg.handle = bo_exynos4412->gem;
         if (drmIoctl (bo_exynos4412->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &arg))
         {
-            TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                    "error %s:%d Cannot dmabuf=%d\n",
-                    getpid(), __FUNCTION__, __LINE__, bo_exynos4412->gem);
+            TBM_EXYNOS4412_LOG ("error Cannot dmabuf=%d\n", bo_exynos4412->gem);
             free (bo_exynos4412);
             return 0;
         }
@@ -515,15 +493,14 @@ tbm_exynos4412_bo_alloc (tbm_bo bo, int size, int flags)
     privGem->ref_count = 1;
     if (drmHashInsert(bufmgr_exynos4412->hashBos, bo_exynos4412->name, (void *)privGem) < 0)
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                 "error %s:%d Cannot insert bo to Hash(%d)\n",
-                 getpid(), __FUNCTION__, __LINE__, bo_exynos4412->name);
+        TBM_EXYNOS4412_LOG ("error Cannot insert bo to Hash(%d)\n", bo_exynos4412->name);
     }
 
-    DBG ("[libtbm-exynos4412:%d] %s size:%d, gem:%d(%d), flags:%d(%d)\n", getpid(),
-         __FUNCTION__, bo_exynos4412->size,
+    DBG ("     [%s] bo:%p, gem:%d(%d), flags:%d(%d), size:%d\n", target_name(),
+         bo,
          bo_exynos4412->gem, bo_exynos4412->name,
-         flags, exynos_flags);
+         flags, exynos_flags,
+         bo_exynos4412->size);
 
     return (void *)bo_exynos4412;
 }
@@ -543,16 +520,18 @@ tbm_exynos4412_bo_free(tbm_bo bo)
     bo_exynos4412 = (tbm_bo_exynos4412)tbm_backend_get_bo_priv(bo);
     EXYNOS4412_RETURN_IF_FAIL (bo_exynos4412!=NULL);
 
-    DBG ("[libtbm-exynos4412:%d] %s size:%d, gem:%d(%d)\n",
-         getpid(), __FUNCTION__, bo_exynos4412->size, bo_exynos4412->gem, bo_exynos4412->name);
+    DBG ("      [%s] bo:%p, gem:%d(%d), fd:%d, size:%d\n",target_name(),
+         bo,
+         bo_exynos4412->gem, bo_exynos4412->name,
+         bo_exynos4412->dmabuf,
+         bo_exynos4412->size);
 
     if (bo_exynos4412->pBase)
     {
         if (munmap(bo_exynos4412->pBase, bo_exynos4412->size) == -1)
         {
-            TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                     "error %s:%d\n",
-                     getpid(), __FUNCTION__, __LINE__);
+            TBM_EXYNOS4412_LOG ("error bo:%p fail to munmap(%s)\n",
+                bo, strerror(errno));
         }
     }
 
@@ -580,9 +559,7 @@ tbm_exynos4412_bo_free(tbm_bo bo)
     }
     else
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                 "warning %s:%d Cannot find bo to Hash(%d), ret=%d\n",
-                 getpid(), __FUNCTION__, __LINE__, bo_exynos4412->name, ret);
+        TBM_EXYNOS4412_LOG ("warning Cannot find bo to Hash(%d), ret=%d\n", bo_exynos4412->name, ret);
     }
 
     /* Free gem handle */
@@ -591,9 +568,8 @@ tbm_exynos4412_bo_free(tbm_bo bo)
     arg.handle = bo_exynos4412->gem;
     if (drmIoctl (bo_exynos4412->fd, DRM_IOCTL_GEM_CLOSE, &arg))
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                 "error %s:%d\n",
-                 getpid(), __FUNCTION__, __LINE__);
+        TBM_EXYNOS4412_LOG ("error bo:%p fail to gem close.(%s)\n",
+            bo, strerror(errno));
     }
 
     free (bo_exynos4412);
@@ -617,9 +593,7 @@ tbm_exynos4412_bo_import (tbm_bo bo, unsigned int key)
     arg.name = key;
     if (drmIoctl(bufmgr_exynos4412->fd, DRM_IOCTL_GEM_OPEN, &arg))
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                "error %s:%d Cannot open gem name=%d\n",
-                getpid(), __FUNCTION__, __LINE__, key);
+        TBM_EXYNOS4412_LOG ("error Cannot open gem name=%d\n", key);
         return 0;
     }
 
@@ -629,18 +603,14 @@ tbm_exynos4412_bo_import (tbm_bo bo, unsigned int key)
                            &info,
                            sizeof(struct drm_exynos_gem_info)))
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                "error %s:%d Cannot get gem info=%d\n",
-                getpid(), __FUNCTION__, __LINE__, key);
+        TBM_EXYNOS4412_LOG ("error Cannot get gem info=%d\n", key);
         return 0;
     }
 
     bo_exynos4412 = calloc (1, sizeof(struct _tbm_bo_exynos4412));
     if (!bo_exynos4412)
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                "error %s:%d fail to allocate the bo private\n",
-                getpid(), __FUNCTION__, __LINE__);
+        TBM_EXYNOS4412_LOG ("error fail to allocate the bo private\n");
         return 0;
     }
 
@@ -658,9 +628,7 @@ tbm_exynos4412_bo_import (tbm_bo bo, unsigned int key)
         arg.handle = bo_exynos4412->gem;
         if (drmIoctl (bo_exynos4412->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &arg))
         {
-            TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                    "error %s:%d Cannot dmabuf=%d\n",
-                    getpid(), __FUNCTION__, __LINE__, bo_exynos4412->gem);
+            TBM_EXYNOS4412_LOG ("error Cannot dmabuf=%d\n", bo_exynos4412->gem);
             free (bo_exynos4412);
             return 0;
         }
@@ -682,22 +650,20 @@ tbm_exynos4412_bo_import (tbm_bo bo, unsigned int key)
         privGem->ref_count = 1;
         if (drmHashInsert (bufmgr_exynos4412->hashBos, bo_exynos4412->name, (void *)privGem) < 0)
         {
-            TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                    "error %s:%d Cannot insert bo to Hash(%d)\n",
-                    getpid(), __FUNCTION__, __LINE__, bo_exynos4412->name);
+            TBM_EXYNOS4412_LOG ("error Cannot insert bo to Hash(%d)\n", bo_exynos4412->name);
         }
     }
     else
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                "error %s:%d Cannot insert bo to Hash(%d)\n",
-                getpid(), __FUNCTION__, __LINE__, bo_exynos4412->name);
+        TBM_EXYNOS4412_LOG ("error Cannot insert bo to Hash(%d)\n", bo_exynos4412->name);
     }
 
-    DBG ("[libtbm-exynos4412:%d] %s size:%d, gem:%d(%d, %d), flags:%d(%d)\n", getpid(),
-         __FUNCTION__, bo_exynos4412->size,
-         bo_exynos4412->gem, bo_exynos4412->name, bo_exynos4412->dmabuf,
-         bo_exynos4412->flags_tbm, bo_exynos4412->flags_exynos);
+    DBG ("    [%s] bo:%p, gem:%d(%d), fd:%d, flags:%d(%d), size:%d\n", target_name(),
+         bo,
+         bo_exynos4412->gem, bo_exynos4412->name,
+         bo_exynos4412->dmabuf,
+         bo_exynos4412->flags_tbm, bo_exynos4412->flags_exynos,
+         bo_exynos4412->size);
 
     return (void *)bo_exynos4412;
 }
@@ -724,9 +690,8 @@ tbm_exynos4412_bo_import_fd (tbm_bo bo, tbm_fd key)
        arg.flags = 0;
     if (drmIoctl (bufmgr_exynos4412->fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &arg))
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                 "error %s:%d Cannot getting gem from prime fd=%d\n",
-                 getpid(), __FUNCTION__, __LINE__, arg.fd);
+        TBM_EXYNOS4412_LOG ("error bo:%p Cannot get gem handle from fd:%d (%s)\n",
+                 bo, arg.fd, strerror(errno));
         return NULL;
     }
     gem = arg.handle;
@@ -744,9 +709,8 @@ tbm_exynos4412_bo_import_fd (tbm_bo bo, tbm_fd key)
                            &info,
                            sizeof(struct drm_exynos_gem_info)))
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                "error %s:%d Cannot get gem info=%d\n",
-                getpid(), __FUNCTION__, __LINE__, key);
+        TBM_EXYNOS4412_LOG ("error bo:%p Cannot get gem info from gem:%d, fd:%d (%s)\n",
+                bo, gem, key, strerror(errno));
         return 0;
     }
 
@@ -756,9 +720,7 @@ tbm_exynos4412_bo_import_fd (tbm_bo bo, tbm_fd key)
     bo_exynos4412 = calloc (1, sizeof(struct _tbm_bo_exynos4412));
     if (!bo_exynos4412)
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                "error %s:%d fail to allocate the bo private\n",
-                getpid(), __FUNCTION__, __LINE__);
+        TBM_EXYNOS4412_LOG ("error bo:%p fail to allocate the bo private\n", bo);
         return 0;
     }
 
@@ -771,14 +733,11 @@ tbm_exynos4412_bo_import_fd (tbm_bo bo, tbm_fd key)
     bo_exynos4412->name = _get_name(bo_exynos4412->fd, bo_exynos4412->gem);
     if (!bo_exynos4412->name)
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                "error %s:%d Cannot get name\n",
-                getpid(), __FUNCTION__, __LINE__);
+        TBM_EXYNOS4412_LOG ("error bo:%p Cannot get name from gem:%d, fd:%d (%s)\n",
+            bo, gem, key, strerror(errno));
         return 0;
     }
 
-       bo_exynos4412->dmabuf = (unsigned int)key;
-
     /* add bo to hash */
     PrivGem *privGem = NULL;
     int ret;
@@ -794,22 +753,23 @@ tbm_exynos4412_bo_import_fd (tbm_bo bo, tbm_fd key)
         privGem->ref_count = 1;
         if (drmHashInsert (bufmgr_exynos4412->hashBos, bo_exynos4412->name, (void *)privGem) < 0)
         {
-            TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                    "error %s:%d Cannot insert bo to Hash(%d)\n",
-                    getpid(), __FUNCTION__, __LINE__, bo_exynos4412->name);
+            TBM_EXYNOS4412_LOG ("error bo:%p Cannot insert bo to Hash(%d) from gem:%d, fd:%d\n",
+                bo, bo_exynos4412->name, gem, key);
         }
     }
     else
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                "error %s:%d Cannot insert bo to Hash(%d)\n",
-                getpid(), __FUNCTION__, __LINE__, bo_exynos4412->name);
+        TBM_EXYNOS4412_LOG ("error bo:%p Cannot insert bo to Hash(%d) from gem:%d, fd:%d\n",
+                bo, bo_exynos4412->name, gem, key);
     }
 
-    DBG ("[libtbm-exynos4412:%d] %s size:%d, gem:%d(%d,%d), flags:%d(%d)\n", getpid(),
-         __FUNCTION__, bo_exynos4412->size,
-         bo_exynos4412->gem, bo_exynos4412->name, bo_exynos4412->dmabuf,
-         bo_exynos4412->flags_tbm, bo_exynos4412->flags_exynos);
+    DBG (" [%s] bo:%p, gem:%d(%d), fd:%d, key_fd:%d, flags:%d(%d), size:%d\n", target_name(),
+         bo,
+         bo_exynos4412->gem, bo_exynos4412->name,
+         bo_exynos4412->dmabuf,
+         key,
+         bo_exynos4412->flags_tbm, bo_exynos4412->flags_exynos,
+         bo_exynos4412->size);
 
     return (void *)bo_exynos4412;
 }
@@ -829,17 +789,17 @@ tbm_exynos4412_bo_export (tbm_bo bo)
         bo_exynos4412->name = _get_name(bo_exynos4412->fd, bo_exynos4412->gem);
         if (!bo_exynos4412->name)
         {
-            TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                    "error %s:%d Cannot get name\n",
-                    getpid(), __FUNCTION__, __LINE__);
+            TBM_EXYNOS4412_LOG ("error Cannot get name\n");
             return 0;
         }
     }
 
-    DBG ("[libtbm-exynos4412:%d] %s size:%d, gem:%d(%d), flags:%d(%d)\n", getpid(),
-         __FUNCTION__, bo_exynos4412->size,
+    DBG ("    [%s] bo:%p, gem:%d(%d), fd:%d, flags:%d(%d), size:%d\n", target_name(),
+         bo,
          bo_exynos4412->gem, bo_exynos4412->name,
-         bo_exynos4412->flags_tbm, bo_exynos4412->flags_exynos);
+         bo_exynos4412->dmabuf,
+         bo_exynos4412->flags_tbm, bo_exynos4412->flags_exynos,
+         bo_exynos4412->size);
 
     return (unsigned int)bo_exynos4412->name;
 }
@@ -854,27 +814,25 @@ tbm_exynos4412_bo_export_fd (tbm_bo bo)
     bo_exynos4412 = (tbm_bo_exynos4412)tbm_backend_get_bo_priv(bo);
     EXYNOS4412_RETURN_VAL_IF_FAIL (bo_exynos4412!=NULL, 0);
 
-    if (!bo_exynos4412->dmabuf)
-    {
-        struct drm_prime_handle arg = {0, };
+    struct drm_prime_handle arg = {0, };
 
-        arg.handle = bo_exynos4412->gem;
-        if (drmIoctl (bo_exynos4412->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &arg))
-        {
-            TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                     "error %s:%d Cannot dmabuf=%d\n",
-                     getpid(), __FUNCTION__, __LINE__, bo_exynos4412->gem);
-            return (tbm_fd) 0;
-        }
-        bo_exynos4412->dmabuf = arg.fd;
+    arg.handle = bo_exynos4412->gem;
+    if (drmIoctl (bo_exynos4412->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &arg))
+    {
+        TBM_EXYNOS4412_LOG ("error bo:%p Cannot dmabuf=%d (%s)\n",
+            bo, bo_exynos4412->gem, strerror(errno));
+        return (tbm_fd) NULL;
     }
 
-    DBG ("[libtbm-exynos4412:%d] %s size:%d, gem:%d(%d, %d), flags:%d(%d)\n", getpid(),
-         __FUNCTION__, bo_exynos4412->size,
-         bo_exynos4412->gem, bo_exynos4412->name, bo_exynos4412->dmabuf,
-         bo_exynos4412->flags_tbm, bo_exynos4412->flags_exynos);
+    DBG (" [%s] bo:%p, gem:%d(%d), fd:%d, key_fd:%d, flags:%d(%d), size:%d\n", target_name(),
+         bo,
+         bo_exynos4412->gem, bo_exynos4412->name,
+         bo_exynos4412->dmabuf,
+         arg.fd,
+         bo_exynos4412->flags_tbm, bo_exynos4412->flags_exynos,
+         bo_exynos4412->size);
 
-    return (tbm_fd)bo_exynos4412->dmabuf;
+    return (tbm_fd)arg.fd;
 }
 
 static tbm_bo_handle
@@ -890,22 +848,23 @@ tbm_exynos4412_bo_get_handle (tbm_bo bo, int device)
 
     if (!bo_exynos4412->gem)
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                "error %s:%d Cannot map gem=%d\n",
-                getpid(), __FUNCTION__, __LINE__, bo_exynos4412->gem);
+        TBM_EXYNOS4412_LOG ("error Cannot map gem=%d\n", bo_exynos4412->gem);
         return (tbm_bo_handle) NULL;
     }
 
-    DBG ("[libtbm-exynos4412:%d] %s gem:%d(%d), %s\n", getpid(),
-         __FUNCTION__, bo_exynos4412->gem, bo_exynos4412->name, STR_DEVICE[device]);
+    DBG ("[%s] bo:%p, gem:%d(%d), fd:%d, flags:%d(%d), size:%d, %s\n", target_name(),
+         bo,
+         bo_exynos4412->gem, bo_exynos4412->name,
+         bo_exynos4412->dmabuf,
+         bo_exynos4412->flags_tbm, bo_exynos4412->flags_exynos,
+         bo_exynos4412->size,
+         STR_DEVICE[device]);
 
     /*Get mapped bo_handle*/
     bo_handle = _exynos4412_bo_handle (bo_exynos4412, device);
     if (bo_handle.ptr == NULL)
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                "error %s:%d Cannot get handle: gem:%d, device:%d\n",
-                getpid(), __FUNCTION__, __LINE__, bo_exynos4412->gem, device);
+        TBM_EXYNOS4412_LOG ("error Cannot get handle: gem:%d, device:%d\n", bo_exynos4412->gem, device);
         return (tbm_bo_handle) NULL;
     }
 
@@ -925,22 +884,22 @@ tbm_exynos4412_bo_map (tbm_bo bo, int device, int opt)
 
     if (!bo_exynos4412->gem)
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                "error %s:%d Cannot map gem=%d\n",
-                getpid(), __FUNCTION__, __LINE__, bo_exynos4412->gem);
+        TBM_EXYNOS4412_LOG ("error Cannot map gem=%d\n", bo_exynos4412->gem);
         return (tbm_bo_handle) NULL;
     }
 
-    DBG ("[libtbm-exynos4412:%d] %s gem:%d(%d), %s, %s\n", getpid(),
-         __FUNCTION__, bo_exynos4412->gem, bo_exynos4412->name, STR_DEVICE[device], STR_OPT[opt]);
+    DBG ("       [%s] bo:%p, gem:%d(%d), fd:%d, %s, %s\n", target_name(),
+         bo,
+         bo_exynos4412->gem, bo_exynos4412->name,
+         bo_exynos4412->dmabuf,
+         STR_DEVICE[device],
+         STR_OPT[opt]);
 
     /*Get mapped bo_handle*/
     bo_handle = _exynos4412_bo_handle (bo_exynos4412, device);
     if (bo_handle.ptr == NULL)
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                "error %s:%d Cannot get handle: gem:%d, device:%d, opt:%d\n",
-                getpid(), __FUNCTION__, __LINE__, bo_exynos4412->gem, device, opt);
+        TBM_EXYNOS4412_LOG ("error Cannot get handle: gem:%d, device:%d, opt:%d\n", bo_exynos4412->gem, device, opt);
         return (tbm_bo_handle) NULL;
     }
 
@@ -960,8 +919,10 @@ tbm_exynos4412_bo_unmap (tbm_bo bo)
     if (!bo_exynos4412->gem)
         return 0;
 
-    DBG ("[libtbm-exynos4412:%d] %s gem:%d(%d) \n", getpid(),
-         __FUNCTION__, bo_exynos4412->gem, bo_exynos4412->name);
+    DBG ("     [%s] bo:%p, gem:%d(%d), fd:%d\n", target_name(),
+          bo,
+          bo_exynos4412->gem, bo_exynos4412->name,
+          bo_exynos4412->dmabuf);
 
     return 1;
 }
@@ -1048,16 +1009,14 @@ tbm_exynos4412_bo_lock(tbm_bo bo, int device, int opt)
     }
     else
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] error %s:%d Invalid argument\n", getpid(), __FUNCTION__, __LINE__);
+        TBM_EXYNOS4412_LOG ("error Invalid argument\n");
         return 0;
     }
 
     /* Check if the tbm manager supports dma fence or not. */
     if (!bufmgr_exynos4412->use_dma_fence)
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                "error %s:%d  Not support DMA FENCE(%s)\n",
-                getpid(), __FUNCTION__, __LINE__, strerror(errno) );
+        TBM_EXYNOS4412_LOG ("error Not support DMA FENCE(%s)\n", strerror(errno) );
         return 0;
 
     }
@@ -1067,9 +1026,7 @@ tbm_exynos4412_bo_lock(tbm_bo bo, int device, int opt)
         ret = ioctl(bo_exynos4412->dmabuf, DMABUF_IOCTL_GET_FENCE, &fence);
         if (ret < 0)
         {
-            TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                    "error %s:%d  Can not set GET FENCE(%s)\n",
-                    getpid(), __FUNCTION__, __LINE__, strerror(errno) );
+            TBM_EXYNOS4412_LOG ("error Cannot set GET FENCE(%s)\n", strerror(errno) );
             return 0;
         }
     } else
@@ -1107,16 +1064,16 @@ tbm_exynos4412_bo_lock(tbm_bo bo, int device, int opt)
         if (i == DMA_FENCE_LIST_MAX)
         {
             //TODO: if dma_fence list is full, it needs realloc. I will fix this. by minseok3.kim
-            TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                    "error %s:%d  fence list is full\n",
-                    getpid(), __FUNCTION__, __LINE__);
+            TBM_EXYNOS4412_LOG ("error fence list is full\n");
         }
     }
 
     pthread_mutex_unlock(&bo_exynos4412->mutex);
 
-    DBG ("[libtbm-exynos4412:%d] %s DMABUF_IOCTL_GET_FENCE! flink_id=%d dmabuf=%d\n", getpid(),
-            __FUNCTION__, bo_exynos4412->name, bo_exynos4412->dmabuf);
+    DBG ("[%s] DMABUF_IOCTL_GET_FENCE! bo:%p, gem:%d(%d), fd:%ds\n", target_name(),
+          bo,
+          bo_exynos4412->gem, bo_exynos4412->name,
+          bo_exynos4412->dmabuf);
 
     return 1;
 }
@@ -1172,9 +1129,7 @@ tbm_exynos4412_bo_unlock(tbm_bo bo)
         ret = ioctl(bo_exynos4412->dmabuf, DMABUF_IOCTL_PUT_FENCE, &fence);
         if (ret < 0)
         {
-            TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] "
-                    "error %s:%d  Can not set PUT FENCE(%s)\n",
-                    getpid(), __FUNCTION__, __LINE__, strerror(errno) );
+            TBM_EXYNOS4412_LOG ("error Can not set PUT FENCE(%s)\n", strerror(errno));
             return 0;
         }
     } else
@@ -1190,8 +1145,10 @@ tbm_exynos4412_bo_unlock(tbm_bo bo)
        }
     }
 
-    DBG ("[libtbm-exynos4412:%d] %s DMABUF_IOCTL_PUT_FENCE! flink_id=%d dmabuf=%d\n", getpid(),
-            __FUNCTION__, bo_exynos4412->name, bo_exynos4412->dmabuf);
+    DBG ("[%s] DMABUF_IOCTL_PUT_FENCE! bo:%p, gem:%d(%d), fd:%ds\n", target_name(),
+          bo,
+          bo_exynos4412->gem, bo_exynos4412->name,
+          bo_exynos4412->dmabuf);
 
     return 1;
 }
@@ -1665,6 +1622,55 @@ tbm_exynos4412_surface_get_size(tbm_surface_h surface, int width, int height, tb
 
 }
 
+tbm_bo_handle
+tbm_exynos4412_fd_to_handle(tbm_bufmgr bufmgr, tbm_fd fd, int device)
+{
+    EXYNOS4412_RETURN_VAL_IF_FAIL (bufmgr!=NULL, (tbm_bo_handle) NULL);
+    EXYNOS4412_RETURN_VAL_IF_FAIL (fd > 0, (tbm_bo_handle) NULL);
+
+    tbm_bo_handle bo_handle;
+    memset (&bo_handle, 0x0, sizeof (uint64_t));
+
+    tbm_bufmgr_exynos4412 bufmgr_exynos4412 = (tbm_bufmgr_exynos4412)tbm_backend_get_priv_from_bufmgr(bufmgr);
+
+    switch(device)
+    {
+    case TBM_DEVICE_DEFAULT:
+    case TBM_DEVICE_2D:
+    {
+        //getting handle from fd
+        struct drm_prime_handle arg = {0, };
+
+        arg.fd = fd;
+        arg.flags = 0;
+        if (drmIoctl (bufmgr_exynos4412->fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &arg))
+        {
+            TBM_EXYNOS4412_LOG ("error Cannot get gem handle from fd:%d (%s)\n",
+                     arg.fd, strerror(errno));
+            return (tbm_bo_handle) NULL;
+        }
+
+        bo_handle.u32 = (uint32_t)arg.handle;;
+        break;
+    }
+    case TBM_DEVICE_CPU:
+        TBM_EXYNOS4412_LOG ("Not supported device:%d\n", device);
+        bo_handle.ptr = (void *) NULL;
+        break;
+    case TBM_DEVICE_3D:
+    case TBM_DEVICE_MM:
+        bo_handle.u32 = (uint32_t)fd;
+        break;
+    default:
+        TBM_EXYNOS4412_LOG ("error Not supported device:%d\n", device);
+        bo_handle.ptr = (void *) NULL;
+        break;
+    }
+
+    return bo_handle;
+}
+
+
 MODULEINITPPROTO (init_tbm_bufmgr_priv);
 
 static TBMModuleVersionInfo Exynos4412VersRec =
@@ -1688,14 +1694,14 @@ init_tbm_bufmgr_priv (tbm_bufmgr bufmgr, int fd)
     bufmgr_exynos4412 = calloc (1, sizeof(struct _tbm_bufmgr_exynos4412));
     if (!bufmgr_exynos4412)
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] error: Fail to alloc bufmgr_exynos4412!\n", getpid());
+        TBM_EXYNOS4412_LOG ("error: Fail to alloc bufmgr_exynos4412!\n");
         return 0;
     }
 
     bufmgr_exynos4412->fd = fd;
     if (bufmgr_exynos4412->fd < 0)
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] error: Fail to create drm!\n", getpid());
+        TBM_EXYNOS4412_LOG ("error: Fail to create drm!\n");
         free (bufmgr_exynos4412);
         return 0;
     }
@@ -1720,7 +1726,9 @@ init_tbm_bufmgr_priv (tbm_bufmgr bufmgr, int fd)
     bufmgr_backend = tbm_backend_alloc();
     if (!bufmgr_backend)
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] error: Fail to create drm!\n", getpid());
+        TBM_EXYNOS4412_LOG ("error: Fail to create drm!\n");
+        if (bufmgr_exynos4412->hashBos)
+            drmHashDestroy (bufmgr_exynos4412->hashBos);
         free (bufmgr_exynos4412);
         return 0;
     }
@@ -1742,6 +1750,7 @@ init_tbm_bufmgr_priv (tbm_bufmgr bufmgr, int fd)
     bufmgr_backend->surface_get_plane_data = tbm_exynos4412_surface_get_plane_data;
     bufmgr_backend->surface_get_size = tbm_exynos4412_surface_get_size;
     bufmgr_backend->surface_supported_format = tbm_exynos4412_surface_supported_format;
+    bufmgr_backend->fd_to_handle = tbm_exynos4412_fd_to_handle;
 
     if (bufmgr_exynos4412->use_dma_fence)
     {
@@ -1759,7 +1768,7 @@ init_tbm_bufmgr_priv (tbm_bufmgr bufmgr, int fd)
 
     if (!tbm_backend_init (bufmgr, bufmgr_backend))
     {
-        TBM_EXYNOS4412_LOG ("[libtbm-exynos4412:%d] error: Fail to init backend!\n", getpid());
+        TBM_EXYNOS4412_LOG ("error: Fail to init backend!\n");
         tbm_backend_free (bufmgr_backend);
         free (bufmgr_exynos4412);
         return 0;
@@ -1781,11 +1790,11 @@ init_tbm_bufmgr_priv (tbm_bufmgr bufmgr, int fd)
     }
 #endif
 
-    DBG ("[libtbm-exynos4412:%d] %s DMABUF FENCE is %s\n", getpid(),
-         __FUNCTION__, bufmgr_exynos4412->use_dma_fence ? "supported!" : "NOT supported!");
+    DBG ("[%s] DMABUF FENCE is %s\n", target_name(),
+          bufmgr_exynos4412->use_dma_fence ? "supported!" : "NOT supported!");
 
-    DBG ("[libtbm-exynos4412:%d] %s fd:%d\n", getpid(),
-         __FUNCTION__, bufmgr_exynos4412->fd);
+    DBG ("[%s] drm_fd:%d\n", target_name(),
+          bufmgr_exynos4412->fd);
 
     return 1;
 }