Declare variable at the beginning of function

Change-Id: I5f631f29a5f1f27b84d9129cbf16fdb520175e85

diff --git a/src/tbm_backend_dumb.c b/src/tbm_backend_dumb.c
index fb9f73d..cbda548 100644 (file)
--- a/src/tbm_backend_dumb.c
+++ b/src/tbm_backend_dumb.c
@@ -290,6 +290,9 @@ static hal_tbm_bo_handle
 _dumb_bo_handle(tbm_dumb_bo *bo_data, int device)
 {
        hal_tbm_bo_handle bo_handle;
+       struct drm_prime_handle prime_handle_arg = {0, };
+       struct drm_mode_map_dumb map_dumb_arg = {0, };
+       void *map = NULL;
 
        memset(&bo_handle, 0x0, sizeof(uint64_t));
 
@@ -300,18 +303,16 @@ _dumb_bo_handle(tbm_dumb_bo *bo_data, int device)
                break;
        case HAL_TBM_DEVICE_CPU:
                if (!bo_data->pBase) {
-                       struct drm_mode_map_dumb arg = {0,};
-                       void *map = NULL;
 
-                       arg.handle = bo_data->gem;
-                       if (drmIoctl(bo_data->fd, DRM_IOCTL_MODE_MAP_DUMB, &arg)) {
+                       map_dumb_arg.handle = bo_data->gem;
+                       if (drmIoctl(bo_data->fd, DRM_IOCTL_MODE_MAP_DUMB, &map_dumb_arg)) {
                           TBM_BACKEND_ERR("fail to DRM_IOCTL_MODE_MAP_DUMB bo_data:%p gem:%d",
                                        bo_data->gem);
                           return (hal_tbm_bo_handle) NULL;
                        }
 
                        map = mmap(NULL, bo_data->size, PROT_READ | PROT_WRITE, MAP_SHARED,
-                                                         bo_data->fd, arg.offset);
+                                                         bo_data->fd, map_dumb_arg.offset);
                        if (map == MAP_FAILED) {
                                TBM_BACKEND_ERR("fail to mmap bo_data:%p gem:%d", bo_data, bo_data->gem);
                                return (hal_tbm_bo_handle) NULL;
@@ -322,30 +323,27 @@ _dumb_bo_handle(tbm_dumb_bo *bo_data, int device)
                break;
        case HAL_TBM_DEVICE_3D:
                if (!bo_data->dmabuf) {
-                       struct drm_prime_handle arg = {0, };
 
-                       arg.handle = bo_data->gem;
-                       if (drmIoctl(bo_data->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &arg)) {
+                       prime_handle_arg.handle = bo_data->gem;
+                       if (drmIoctl(bo_data->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &prime_handle_arg)) {
                                TBM_BACKEND_ERR("fail to DRM_IOCTL_PRIME_HANDLE_TO_FD bo_data:%p gem:%d",
                                                bo_data, bo_data->gem);
                                return (hal_tbm_bo_handle) NULL;
                        }
-                       bo_data->dmabuf = arg.fd;
+                       bo_data->dmabuf = prime_handle_arg.fd;
                }
 
                bo_handle.u32 = (uint32_t)bo_data->dmabuf;
                break;
        case HAL_TBM_DEVICE_MM:
                if (!bo_data->dmabuf) {
-                       struct drm_prime_handle arg = {0, };
-
-                       arg.handle = bo_data->gem;
-                       if (drmIoctl(bo_data->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &arg)) {
+                       prime_handle_arg.handle = bo_data->gem;
+                       if (drmIoctl(bo_data->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &prime_handle_arg)) {
                                TBM_BACKEND_ERR("fail to DRM_IOCTL_PRIME_HANDLE_TO_FD bo_data:%p gem:%d",
                                                bo_data, bo_data->gem);
                                return (hal_tbm_bo_handle) NULL;
                        }
-                       bo_data->dmabuf = arg.fd;
+                       bo_data->dmabuf = prime_handle_arg.fd;
                }
 
                bo_handle.u32 = (uint32_t)bo_data->dmabuf;
@@ -656,6 +654,7 @@ tbm_dumb_bufmgr_alloc_bo(hal_tbm_bufmgr *bufmgr, unsigned int size,
        tbm_dumb_bufmgr *bufmgr_data = (tbm_dumb_bufmgr *)bufmgr;
        tbm_dumb_bo *bo_data;
        unsigned int dumb_flags;
+       struct drm_mode_create_dumb create_dumb_arg = {0, };
 
        if (bufmgr_data == NULL) {
                TBM_BACKEND_ERR("bufmgr_data is null");
@@ -675,16 +674,15 @@ tbm_dumb_bufmgr_alloc_bo(hal_tbm_bufmgr *bufmgr, unsigned int size,
 
        dumb_flags = _get_dumb_flag_from_tbm(flags);
 
-       struct drm_mode_create_dumb arg = {0, };
        //as we know only size for new bo set height=1 and bpp=8 and in this case
        //width will by equal to size in bytes;
-       arg.height = 1;
-       arg.bpp = 8;
-       arg.width = size;
-       arg.flags = dumb_flags;
-       if (drmIoctl(bufmgr_data->fd, DRM_IOCTL_MODE_CREATE_DUMB, &arg)) {
+       create_dumb_arg.height = 1;
+       create_dumb_arg.bpp = 8;
+       create_dumb_arg.width = size;
+       create_dumb_arg.flags = dumb_flags;
+       if (drmIoctl(bufmgr_data->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb_arg)) {
                TBM_BACKEND_ERR("fail to DRM_IOCTL_MODE_CREATE_DUMB flag:%x size:%d",
-                               arg.flags, (unsigned int)size);
+                               create_dumb_arg.flags, (unsigned int)size);
                free(bo_data);
                if (error)
                        *error = HAL_TBM_ERROR_INVALID_OPERATION;
@@ -692,8 +690,8 @@ tbm_dumb_bufmgr_alloc_bo(hal_tbm_bufmgr *bufmgr, unsigned int size,
        }
 
        bo_data->fd = bufmgr_data->fd;
-       bo_data->gem = arg.handle;
-       bo_data->size = arg.size;
+       bo_data->gem = create_dumb_arg.handle;
+       bo_data->size = create_dumb_arg.size;
        bo_data->flags_tbm = flags;
        bo_data->flags_dumb = dumb_flags;
        bo_data->name = _get_name(bo_data->fd, bo_data->gem);
@@ -725,6 +723,10 @@ tbm_dumb_bufmgr_import_fd(hal_tbm_bufmgr *bufmgr, hal_tbm_fd key, hal_tbm_error
        tbm_dumb_bo *bo_data;
        unsigned int gem = 0;
        unsigned int name;
+       struct drm_prime_handle prime_handle_arg = {0, };
+       struct drm_gem_open open_arg = {0, };
+       struct drm_gem_close close_arg = {0, };
+       unsigned int real_size = -1;
        int ret;
 
        if (bufmgr_data == NULL) {
@@ -734,19 +736,16 @@ tbm_dumb_bufmgr_import_fd(hal_tbm_bufmgr *bufmgr, hal_tbm_fd key, hal_tbm_error
                return NULL;
        }
 
-       //getting handle from fd
-       struct drm_prime_handle arg = {0, };
-
-       arg.fd = key;
-       arg.flags = 0;
-       if (drmIoctl(bufmgr_data->fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &arg)) {
+       prime_handle_arg.fd = key;
+       prime_handle_arg.flags = 0;
+       if (drmIoctl(bufmgr_data->fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &prime_handle_arg)) {
                TBM_BACKEND_ERR("fail to DRM_IOCTL_PRIME_FD_TO_HANDLE key:%d (%m)",
-                               arg.fd);
+                               prime_handle_arg.fd);
                if (error)
                        *error = HAL_TBM_ERROR_INVALID_OPERATION;
                return NULL;
        }
-       gem = arg.handle;
+       gem = prime_handle_arg.handle;
 
        name = _get_name(bufmgr_data->fd, gem);
        if (name == 0) {
@@ -770,9 +769,6 @@ tbm_dumb_bufmgr_import_fd(hal_tbm_bufmgr *bufmgr, hal_tbm_fd key, hal_tbm_error
         * later, we can lseek on the prime fd to get the size.  Older
         * kernels will just fail, in which case we fall back to the
         * provided (estimated or guess size). */
-       unsigned int real_size = -1;
-       struct drm_gem_open open_arg = {0, };
-
        real_size = lseek(key, 0, SEEK_END);
 
        /* Open the same GEM object only for finding out its size */
@@ -786,9 +782,8 @@ tbm_dumb_bufmgr_import_fd(hal_tbm_bufmgr *bufmgr, hal_tbm_fd key, hal_tbm_error
        }
 
        /* Free gem handle to avoid a memory leak*/
-       struct drm_gem_close gem_close;
-       gem_close.handle = open_arg.handle;
-       if (drmIoctl(bufmgr_data->fd, DRM_IOCTL_GEM_CLOSE, &gem_close)) {
+       close_arg.handle = open_arg.handle;
+       if (drmIoctl(bufmgr_data->fd, DRM_IOCTL_GEM_CLOSE, &close_arg)) {
                TBM_BACKEND_ERR("fail to DRM_IOCTL_GEM_CLOSE gem:%d (%m)", open_arg.handle);
                if (error)
                        *error = HAL_TBM_ERROR_INVALID_OPERATION;
@@ -840,6 +835,8 @@ tbm_dumb_bufmgr_import_key(hal_tbm_bufmgr *bufmgr, hal_tbm_key key, hal_tbm_erro
 {
        tbm_dumb_bufmgr *bufmgr_data = (tbm_dumb_bufmgr *)bufmgr;
        tbm_dumb_bo *bo_data;
+       struct drm_gem_open open_arg = {0, };
+       struct drm_prime_handle prim_handle_arg = {0, };
        int ret;
 
        if (bufmgr_data == NULL) {
@@ -856,10 +853,8 @@ tbm_dumb_bufmgr_import_key(hal_tbm_bufmgr *bufmgr, hal_tbm_key key, hal_tbm_erro
                return (hal_tbm_bo *)bo_data;
        }
 
-       struct drm_gem_open arg = {0, };
-
-       arg.name = key;
-       if (drmIoctl(bufmgr_data->fd, DRM_IOCTL_GEM_OPEN, &arg)) {
+       open_arg.name = key;
+       if (drmIoctl(bufmgr_data->fd, DRM_IOCTL_GEM_OPEN, &open_arg)) {
                TBM_BACKEND_ERR("fail to DRM_IOCTL_GEM_OPEN name:%d", key);
                if (error)
                        *error = HAL_TBM_ERROR_INVALID_OPERATION;
@@ -876,17 +871,15 @@ tbm_dumb_bufmgr_import_key(hal_tbm_bufmgr *bufmgr, hal_tbm_key key, hal_tbm_erro
        bo_data->bufmgr_data = bufmgr_data;
 
        bo_data->fd = bufmgr_data->fd;
-       bo_data->gem = arg.handle;
-       bo_data->size = arg.size;
+       bo_data->gem = open_arg.handle;
+       bo_data->size = open_arg.size;
        bo_data->flags_dumb = 0;
        bo_data->name = key;
        bo_data->flags_tbm = _get_tbm_flag_from_dumb(bo_data->flags_dumb);
 
        if (!bo_data->dmabuf) {
-               struct drm_prime_handle arg = {0, };
-
-               arg.handle = bo_data->gem;
-               if (drmIoctl(bo_data->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &arg)) {
+               prim_handle_arg.handle = bo_data->gem;
+               if (drmIoctl(bo_data->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &prim_handle_arg)) {
                        TBM_BACKEND_ERR("fail to DRM_IOCTL_PRIME_HANDLE_TO_FD bo_data:%p gem:d%d",
                                        bo_data, bo_data->gem);
                        if (error)
@@ -894,7 +887,7 @@ tbm_dumb_bufmgr_import_key(hal_tbm_bufmgr *bufmgr, hal_tbm_key key, hal_tbm_erro
                        free(bo_data);
                        return NULL;
                }
-               bo_data->dmabuf = arg.fd;
+               bo_data->dmabuf = prim_handle_arg.fd;
        }
 
        /* add bo to hash */
@@ -921,6 +914,7 @@ tbm_dumb_bo_free(hal_tbm_bo *bo)
        tbm_dumb_bo *bo_data = (tbm_dumb_bo *)bo;
        tbm_dumb_bo *temp;
        tbm_dumb_bufmgr *bufmgr_data;
+       struct drm_gem_close close_arg = {0, };
        int ret;
 
        if (!bo_data)
@@ -961,11 +955,8 @@ tbm_dumb_bo_free(hal_tbm_bo *bo)
                TBM_BACKEND_ERR("hashBos probably has several BOs with same name!!!");
 
        /* Free gem handle */
-       struct drm_gem_close arg = {0, };
-
-       memset(&arg, 0, sizeof(arg));
-       arg.handle = bo_data->gem;
-       if (drmIoctl(bo_data->fd, DRM_IOCTL_GEM_CLOSE, &arg))
+       close_arg.handle = bo_data->gem;
+       if (drmIoctl(bo_data->fd, DRM_IOCTL_GEM_CLOSE, &close_arg))
                TBM_BACKEND_ERR("fail to gem close bo_data:%p gem:%d (%m)",
                                bo_data, bo_data->gem);
 
@@ -1131,6 +1122,7 @@ hal_tbm_fd
 tbm_dumb_bo_export_fd(hal_tbm_bo *bo, hal_tbm_error *error)
 {
        tbm_dumb_bo *bo_data = (tbm_dumb_bo *)bo;
+       struct drm_prime_handle prime_handle_arg = {0, };
        int ret;
 
        if (!bo_data) {
@@ -1139,10 +1131,8 @@ tbm_dumb_bo_export_fd(hal_tbm_bo *bo, hal_tbm_error *error)
                return -1;
        }
 
-       struct drm_prime_handle arg = {0, };
-
-       arg.handle = bo_data->gem;
-       ret = drmIoctl(bo_data->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &arg);
+       prime_handle_arg.handle = bo_data->gem;
+       ret = drmIoctl(bo_data->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &prime_handle_arg);
        if (ret) {
                TBM_BACKEND_ERR("fail to DRM_IOCTL_PRIME_HANDLE_TO_FD bo_data:%p gem:%d (%m)",
                                bo_data, bo_data->gem);
@@ -1156,14 +1146,14 @@ tbm_dumb_bo_export_fd(hal_tbm_bo *bo, hal_tbm_error *error)
                        bo_data->gem,
                        bo_data->name,
                        bo_data->dmabuf,
-                       arg.fd,
+                       prime_handle_arg.fd,
                        bo_data->flags_tbm,
                        bo_data->size);
 
        if (error)
                *error = HAL_TBM_ERROR_NONE;
 
-       return (hal_tbm_fd)arg.fd;
+       return (hal_tbm_fd)prime_handle_arg.fd;
 }
 
 static hal_tbm_key