bo: add _tbm_set_last_error()

Change-Id: I7891946a21920ff9da0da3cfd68aaf4a5c787698

diff --git a/src/tbm_bo.c b/src/tbm_bo.c
index f63d99d..f2870c9 100644 (file)
--- a/src/tbm_bo.c
+++ b/src/tbm_bo.c
@@ -41,6 +41,7 @@ static void _tbm_bo_mutex_unlock(void);
 #define TBM_BO_RETURN_IF_FAIL(cond) {\
        if (!(cond)) {\
                TBM_ERR("'%s' failed.\n", #cond);\
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\
                _tbm_bo_mutex_unlock();\
                return;\
        } \
@@ -49,6 +50,7 @@ static void _tbm_bo_mutex_unlock(void);
 #define TBM_BO_RETURN_VAL_IF_FAIL(cond, val) {\
        if (!(cond)) {\
                TBM_ERR("'%s' failed.\n", #cond);\
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\
                _tbm_bo_mutex_unlock();\
                return val;\
        } \
@@ -137,8 +139,8 @@ _tbm_util_check_bo_cnt(tbm_bufmgr bufmgr)
 }
 /* LCOV_EXCL_STOP */
 
-tbm_user_data
-*user_data_lookup(struct list_head *user_data_list, unsigned long key)
+tbm_user_data *
+user_data_lookup(struct list_head *user_data_list, unsigned long key)
 {
        tbm_user_data *old_data = NULL;
 
@@ -153,8 +155,8 @@ tbm_user_data
        return NULL;
 }
 
-tbm_user_data
-*user_data_create(unsigned long key, tbm_data_free data_free_func)
+tbm_user_data *
+user_data_create(unsigned long key, tbm_data_free data_free_func)
 {
        tbm_user_data *user_data;
 
@@ -162,6 +164,7 @@ tbm_user_data
        if (!user_data) {
                /* LCOV_EXCL_START */
                TBM_ERR("fail to allocate an user_date\n");
+               _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
                return NULL;
                /* LCOV_EXCL_STOP */
        }
@@ -194,12 +197,16 @@ _bo_lock(tbm_bo bo, int device, int opt)
                        error = bo->bufmgr->bo_func->bo_lock(bo->bo_data, device, opt);
                        if (error != TBM_ERROR_NONE) {
                                TBM_WRN("fail to lock");
+                               _tbm_set_last_result(error);
                                ret = 0;
                        }
                }
        } else {
-               if (bo->bufmgr->backend->bo_lock)
+               if (bo->bufmgr->backend->bo_lock) {
                        ret = bo->bufmgr->backend->bo_lock(bo, device, opt);
+                       if (!ret)
+                               _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
+               }
        }
 
        return ret;
@@ -213,8 +220,10 @@ _bo_unlock(tbm_bo bo)
        if (bo->bufmgr->backend_module_data) {
                if (bo->bufmgr->bo_func->bo_unlock) {
                        error = bo->bufmgr->bo_func->bo_unlock(bo->bo_data);
-                       if (error != TBM_ERROR_NONE)
+                       if (error != TBM_ERROR_NONE) {
                                TBM_WRN("fail to unlock");
+                               _tbm_set_last_result(error);
+                       }
                }
        } else {
                if (bo->bufmgr->backend->bo_unlock)
@@ -350,6 +359,7 @@ tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags)
        tbm_error_e error;
 
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
        TBM_BO_RETURN_VAL_IF_FAIL(size > 0, NULL);
@@ -359,7 +369,7 @@ tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags)
                /* LCOV_EXCL_START */
                TBM_ERR("error: fail to create of tbm_bo size(%d) flag(%s)\n",
                                size, _tbm_flag_to_str(flags));
-               _tbm_set_last_result(TBM_BO_ERROR_HEAP_ALLOC_FAILED);
+               _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
                _tbm_bo_mutex_unlock();
                return NULL;
                /* LCOV_EXCL_STOP */
@@ -375,7 +385,7 @@ tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags)
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: fail to create of tbm_bo size(%d) flag(%s)\n",
                                        size, _tbm_flag_to_str(flags));
-                       _tbm_set_last_result(TBM_BO_ERROR_BO_ALLOC_FAILED);
+                       _tbm_set_last_result(error);
                        free(bo);
                        _tbm_bo_mutex_unlock();
                        return NULL;
@@ -388,7 +398,7 @@ tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags)
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: fail to create of tbm_bo size(%d) flag(%s)\n",
                                        size, _tbm_flag_to_str(flags));
-                       _tbm_set_last_result(TBM_BO_ERROR_BO_ALLOC_FAILED);
+                       _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
                        free(bo);
                        _tbm_bo_mutex_unlock();
                        return NULL;
@@ -417,6 +427,7 @@ tbm_bo
 tbm_bo_ref(tbm_bo bo)
 {
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), NULL);
 
@@ -433,6 +444,7 @@ void
 tbm_bo_unref(tbm_bo bo)
 {
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_IF_FAIL(_tbm_bo_is_valid(bo));
 
@@ -457,11 +469,11 @@ tbm_bo_map(tbm_bo bo, int device, int opt)
        tbm_error_e error;
 
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), (tbm_bo_handle) NULL);
 
        if (!_tbm_bo_lock(bo, device, opt)) {
-               _tbm_set_last_result(TBM_BO_ERROR_LOCK_FAILED);
                TBM_ERR("error: fail to lock bo:%p)\n", bo);
                _tbm_bo_mutex_unlock();
                return (tbm_bo_handle) NULL;
@@ -471,7 +483,7 @@ tbm_bo_map(tbm_bo bo, int device, int opt)
                bo_handle = bo->bufmgr->bo_func->bo_map(bo->bo_data, device, opt, &error);
                if (bo_handle.ptr == NULL) {
                        /* LCOV_EXCL_START */
-                       _tbm_set_last_result(TBM_BO_ERROR_MAP_FAILED);
+                       _tbm_set_last_result(error);
                        TBM_ERR("error: fail to map bo:%p error:%d\n", bo, error);
                        _tbm_bo_unlock(bo);
                        _tbm_bo_mutex_unlock();
@@ -482,7 +494,7 @@ tbm_bo_map(tbm_bo bo, int device, int opt)
                bo_handle = bo->bufmgr->backend->bo_map(bo, device, opt);
                if (bo_handle.ptr == NULL) {
                        /* LCOV_EXCL_START */
-                       _tbm_set_last_result(TBM_BO_ERROR_MAP_FAILED);
+                       _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
                        TBM_ERR("error: fail to map bo:%p\n", bo);
                        _tbm_bo_unlock(bo);
                        _tbm_bo_mutex_unlock();
@@ -508,6 +520,7 @@ tbm_bo_unmap(tbm_bo bo)
        tbm_error_e error;
 
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
        TBM_BO_RETURN_VAL_IF_FAIL(bo->map_cnt > 0, 0);
@@ -517,7 +530,7 @@ tbm_bo_unmap(tbm_bo bo)
                if (error != TBM_ERROR_NONE) {
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: bo(%p) map_cnt(%d) error(%d)\n", bo, bo->map_cnt, error);
-                       _tbm_set_last_result(TBM_BO_ERROR_UNMAP_FAILED);
+                       _tbm_set_last_result(error);
                        ret = 0;
                        _tbm_bo_mutex_unlock();
                        return ret;
@@ -528,7 +541,7 @@ tbm_bo_unmap(tbm_bo bo)
                if (!ret) {
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: bo(%p) map_cnt(%d)\n", bo, bo->map_cnt);
-                       _tbm_set_last_result(TBM_BO_ERROR_UNMAP_FAILED);
+                       _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
                        _tbm_bo_mutex_unlock();
                        return ret;
                        /* LCOV_EXCL_STOP */
@@ -554,6 +567,7 @@ tbm_bo_get_handle(tbm_bo bo, int device)
        tbm_error_e error;
 
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), (tbm_bo_handle) NULL);
 
@@ -561,8 +575,8 @@ tbm_bo_get_handle(tbm_bo bo, int device)
                bo_handle = bo->bufmgr->bo_func->bo_get_handle(bo->bo_data, device, &error);
                if (bo_handle.ptr == NULL) {
                        /* LCOV_EXCL_START */
-                       _tbm_set_last_result(TBM_BO_ERROR_GET_HANDLE_FAILED);
                        TBM_ERR("error: bo(%p) bo_handle(%p) error(%d)\n", bo, bo_handle.ptr, error);
+                       _tbm_set_last_result(error);
                        _tbm_bo_mutex_unlock();
                        return (tbm_bo_handle) NULL;
                        /* LCOV_EXCL_STOP */
@@ -571,8 +585,8 @@ tbm_bo_get_handle(tbm_bo bo, int device)
                bo_handle = bo->bufmgr->backend->bo_get_handle(bo, device);
                if (bo_handle.ptr == NULL) {
                        /* LCOV_EXCL_START */
-                       _tbm_set_last_result(TBM_BO_ERROR_GET_HANDLE_FAILED);
                        TBM_ERR("error: bo(%p) bo_handle(%p)\n", bo, bo_handle.ptr);
+                       _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
                        _tbm_bo_mutex_unlock();
                        return (tbm_bo_handle) NULL;
                        /* LCOV_EXCL_STOP */
@@ -593,6 +607,7 @@ tbm_bo_export(tbm_bo bo)
        tbm_error_e error;
 
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
 
@@ -600,6 +615,7 @@ tbm_bo_export(tbm_bo bo)
                if (!bo->bufmgr->bo_func->bo_export_key) {
                        /* LCOV_EXCL_START */
                        _tbm_bo_mutex_unlock();
+                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
                        return 0;
                        /* LCOV_EXCL_STOP */
                }
@@ -607,8 +623,8 @@ tbm_bo_export(tbm_bo bo)
                ret = bo->bufmgr->bo_func->bo_export_key(bo->bo_data, &error);
                if (!ret) {
                        /* LCOV_EXCL_START */
-                       _tbm_set_last_result(TBM_BO_ERROR_EXPORT_FAILED);
                        TBM_ERR("error: bo(%p) tbm_key(%d) error(%d)\n", bo, ret, error);
+                       _tbm_set_last_result(error);
                        _tbm_bo_mutex_unlock();
                        return ret;
                        /* LCOV_EXCL_STOP */
@@ -617,6 +633,7 @@ tbm_bo_export(tbm_bo bo)
                if (!bo->bufmgr->backend->bo_export) {
                        /* LCOV_EXCL_START */
                        _tbm_bo_mutex_unlock();
+                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
                        return 0;
                        /* LCOV_EXCL_STOP */
                }
@@ -624,8 +641,8 @@ tbm_bo_export(tbm_bo bo)
                ret = bo->bufmgr->backend->bo_export(bo);
                if (!ret) {
                        /* LCOV_EXCL_START */
-                       _tbm_set_last_result(TBM_BO_ERROR_EXPORT_FAILED);
                        TBM_ERR("error: bo(%p) tbm_key(%d)\n", bo, ret);
+                       _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
                        _tbm_bo_mutex_unlock();
                        return ret;
                        /* LCOV_EXCL_STOP */
@@ -646,6 +663,7 @@ tbm_bo_export_fd(tbm_bo bo)
        tbm_error_e error;
 
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), -1);
 
@@ -653,6 +671,7 @@ tbm_bo_export_fd(tbm_bo bo)
                if (!bo->bufmgr->bo_func->bo_export_fd) {
                        /* LCOV_EXCL_START */
                        _tbm_bo_mutex_unlock();
+                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
                        return -1;
                        /* LCOV_EXCL_STOP */
                }
@@ -660,8 +679,8 @@ tbm_bo_export_fd(tbm_bo bo)
                ret = bo->bufmgr->bo_func->bo_export_fd(bo->bo_data, &error);
                if (ret < 0) {
                        /* LCOV_EXCL_START */
-                       _tbm_set_last_result(TBM_BO_ERROR_EXPORT_FD_FAILED);
                        TBM_ERR("error: bo(%p) tbm_fd(%d) error(%d)\n", bo, ret, error);
+                       _tbm_set_last_result(error);
                        _tbm_bo_mutex_unlock();
                        return ret;
                        /* LCOV_EXCL_STOP */
@@ -670,6 +689,7 @@ tbm_bo_export_fd(tbm_bo bo)
                if (!bo->bufmgr->backend->bo_export_fd) {
                        /* LCOV_EXCL_START */
                        _tbm_bo_mutex_unlock();
+                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
                        return -1;
                        /* LCOV_EXCL_STOP */
                }
@@ -677,8 +697,8 @@ tbm_bo_export_fd(tbm_bo bo)
                ret = bo->bufmgr->backend->bo_export_fd(bo);
                if (ret < 0) {
                        /* LCOV_EXCL_START */
-                       _tbm_set_last_result(TBM_BO_ERROR_EXPORT_FD_FAILED);
                        TBM_ERR("error: bo(%p) tbm_fd(%d)\n", bo, ret);
+                       _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
                        _tbm_bo_mutex_unlock();
                        return ret;
                        /* LCOV_EXCL_STOP */
@@ -702,6 +722,7 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key)
        tbm_backend_bo_data *bo_data;
 
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
 
@@ -709,6 +730,7 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key)
                if (!bufmgr->bufmgr_func->bufmgr_import_key) {
                        /* LCOV_EXCL_START */
                        _tbm_bo_mutex_unlock();
+                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
                        return NULL;
                        /* LCOV_EXCL_STOP */
                }
@@ -716,6 +738,7 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key)
                if (!bufmgr->backend->bo_import) {
                        /* LCOV_EXCL_START */
                        _tbm_bo_mutex_unlock();
+                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
                        return NULL;
                        /* LCOV_EXCL_STOP */
                }
@@ -727,6 +750,7 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key)
        if (!bo) {
                /* LCOV_EXCL_START */
                TBM_ERR("error: fail to import of tbm_bo by key(%d)\n", key);
+               _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
                _tbm_bo_mutex_unlock();
                return NULL;
                /* LCOV_EXCL_STOP */
@@ -739,7 +763,7 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key)
                if (!bo_data) {
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: fail to import of tbm_bo by key(%d). error(%d)\n", key, error);
-                       _tbm_set_last_result(TBM_BO_ERROR_IMPORT_FAILED);
+                       _tbm_set_last_result(error);
                        free(bo);
                        _tbm_bo_mutex_unlock();
                        return NULL;
@@ -765,7 +789,7 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key)
                if (!bo_priv) {
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: fail to import of tbm_bo by key(%d)\n", key);
-                       _tbm_set_last_result(TBM_BO_ERROR_IMPORT_FAILED);
+                       _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
                        free(bo);
                        _tbm_bo_mutex_unlock();
                        return NULL;
@@ -795,6 +819,7 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key)
                bo->flags = bo->bufmgr->bo_func->bo_get_memory_types(bo->bo_data, &error);
                if (error != TBM_ERROR_NONE) {
                        TBM_ERR("fail to get the bo flags(memory_types)");
+                       _tbm_set_last_result(error);
                        bo->flags = TBM_BO_DEFAULT;
                }
        } else {
@@ -826,6 +851,7 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
        tbm_error_e error;
 
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
 
@@ -833,6 +859,7 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
                if (!bufmgr->bufmgr_func->bufmgr_import_fd) {
                        /* LCOV_EXCL_START */
                        _tbm_bo_mutex_unlock();
+                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
                        return NULL;
                        /* LCOV_EXCL_STOP */
                }
@@ -840,6 +867,7 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
                if (!bufmgr->backend->bo_import_fd) {
                        /* LCOV_EXCL_START */
                        _tbm_bo_mutex_unlock();
+                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
                        return NULL;
                        /* LCOV_EXCL_STOP */
                }
@@ -851,6 +879,7 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
        if (!bo) {
                /* LCOV_EXCL_START */
                TBM_ERR("error: fail to import tbm_bo by tbm_fd(%d)\n", fd);
+               _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
                _tbm_bo_mutex_unlock();
                return NULL;
                /* LCOV_EXCL_STOP */
@@ -863,7 +892,7 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
                if (!bo_data) {
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: fail to import tbm_bo by tbm_fd(%d). error(%d)\n", fd, error);
-                       _tbm_set_last_result(TBM_BO_ERROR_IMPORT_FD_FAILED);
+                       _tbm_set_last_result(error);
                        free(bo);
                        _tbm_bo_mutex_unlock();
                        return NULL;
@@ -889,7 +918,7 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
                if (!bo_priv) {
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: fail to import tbm_bo by tbm_fd(%d)\n", fd);
-                       _tbm_set_last_result(TBM_BO_ERROR_IMPORT_FD_FAILED);
+                       _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
                        free(bo);
                        _tbm_bo_mutex_unlock();
                        return NULL;
@@ -919,6 +948,7 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
                bo->flags = bo->bufmgr->bo_func->bo_get_memory_types(bo->bo_data, &error);
                if (error != TBM_ERROR_NONE) {
                        TBM_ERR("fail to get the bo flags(memory_types)");
+                       _tbm_set_last_result(error);
                        bo->flags = TBM_BO_DEFAULT;
                }
        } else {
@@ -947,13 +977,16 @@ tbm_bo_size(tbm_bo bo)
        tbm_error_e error;
 
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
 
        if (bo->bufmgr->backend_module_data) {
                size = bo->bufmgr->bo_func->bo_get_size(bo->bo_data, &error);
-               if (error != TBM_ERROR_NONE)
+               if (error != TBM_ERROR_NONE) {
                        TBM_ERR("fail to get the size of the bo_data(%d).", error);
+                       _tbm_set_last_result(TBM_ERROR_NONE);
+               }
        } else
                size = bo->bufmgr->backend->bo_size(bo);
 
@@ -968,11 +1001,13 @@ int
 tbm_bo_locked(tbm_bo bo)
 {
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
 
        if (bo->bufmgr->bo_lock_type == TBM_BUFMGR_BO_LOCK_TYPE_NEVER) {
                TBM_ERR("bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt);
+               _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
                _tbm_bo_mutex_unlock();
                return 0;
        }
@@ -997,6 +1032,7 @@ tbm_bo_swap(tbm_bo bo1, tbm_bo bo2)
        void *temp;
 
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo1), 0);
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo2), 0);
@@ -1007,11 +1043,13 @@ tbm_bo_swap(tbm_bo bo1, tbm_bo bo2)
                size1 = bo1->bufmgr->bo_func->bo_get_size(bo1->bo_data, &error1);
                if (error1 != TBM_ERROR_NONE) {
                        TBM_ERR("fail to get the size of bo1.(%d)", error1);
+                       _tbm_set_last_result(error1);
                        goto fail;
                }
                size2 = bo2->bufmgr->bo_func->bo_get_size(bo2->bo_data, &error2);
                if (error2 != TBM_ERROR_NONE) {
                        TBM_ERR("fail to get the size of bo2.(%d)", error2);
+                       _tbm_set_last_result(error2);
                        goto fail;
                }
        } else {
@@ -1021,6 +1059,7 @@ tbm_bo_swap(tbm_bo bo1, tbm_bo bo2)
 
        if (size1 != size2) {
                TBM_ERR("error: bo1 size(%d) and bo2 size(%d) is different.", size1, size2);
+               _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
                goto fail;
        }
 
@@ -1035,7 +1074,6 @@ tbm_bo_swap(tbm_bo bo1, tbm_bo bo2)
        return 1;
 
 fail:
-       _tbm_set_last_result(TBM_BO_ERROR_SWAP_FAILED);
        TBM_ERR("error: bo1(%p) bo2(%p)\n", bo1, bo2);
        _tbm_bo_mutex_unlock();
 
@@ -1049,6 +1087,7 @@ tbm_bo_add_user_data(tbm_bo bo, unsigned long key,
        tbm_user_data *data;
 
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
 
@@ -1056,6 +1095,7 @@ tbm_bo_add_user_data(tbm_bo bo, unsigned long key,
        data = user_data_lookup(&bo->user_data_list, key);
        if (data) {
                TBM_TRACE_BO("warning: user data already exist key(%ld)\n", key);
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
                _tbm_bo_mutex_unlock();
                return 0;
        }
@@ -1063,6 +1103,7 @@ tbm_bo_add_user_data(tbm_bo bo, unsigned long key,
        data = user_data_create(key, data_free_func);
        if (!data) {
                TBM_ERR("error: bo(%p) key(%lu)\n", bo, key);
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
                _tbm_bo_mutex_unlock();
                return 0;
        }
@@ -1082,18 +1123,21 @@ tbm_bo_delete_user_data(tbm_bo bo, unsigned long key)
        tbm_user_data *old_data;
 
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
 
        if (LIST_IS_EMPTY(&bo->user_data_list)) {
-               TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
+               TBM_TRACE_BO("bo(%p) key(%lu)\n", bo, key);
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
                _tbm_bo_mutex_unlock();
                return 0;
        }
 
        old_data = user_data_lookup(&bo->user_data_list, key);
        if (!old_data) {
-               TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
+               TBM_TRACE_BO("bo(%p) key(%lu)\n", bo, key);
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
                _tbm_bo_mutex_unlock();
                return 0;
        }
@@ -1113,11 +1157,13 @@ tbm_bo_set_user_data(tbm_bo bo, unsigned long key, void *data)
        tbm_user_data *old_data;
 
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
 
        if (LIST_IS_EMPTY(&bo->user_data_list)) {
                TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
                _tbm_bo_mutex_unlock();
                return 0;
        }
@@ -1125,6 +1171,7 @@ tbm_bo_set_user_data(tbm_bo bo, unsigned long key, void *data)
        old_data = user_data_lookup(&bo->user_data_list, key);
        if (!old_data) {
                TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
                _tbm_bo_mutex_unlock();
                return 0;
        }
@@ -1146,19 +1193,22 @@ tbm_bo_get_user_data(tbm_bo bo, unsigned long key, void **data)
        tbm_user_data *old_data;
 
        _tbm_bo_mutex_lock();
+       _tbm_set_last_result(TBM_ERROR_NONE);
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
 
        if (!data || LIST_IS_EMPTY(&bo->user_data_list)) {
                TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
                _tbm_bo_mutex_unlock();
                return 0;
        }
 
        old_data = user_data_lookup(&bo->user_data_list, key);
        if (!old_data) {
-               TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
                *data = NULL;
+               TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
+               _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
                _tbm_bo_mutex_unlock();
                return 0;
        }