Use strerror_r function instead strerror

strerror makes no guaranteee of thread safety.

Change-Id: I28d829e11259de0485aef3ddf94c4dcfbf52ccbf

diff --git a/src/tbm_bufmgr_exynos.c b/src/tbm_bufmgr_exynos.c
index 3151bcf..8ce6f58 100644 (file)
--- a/src/tbm_bufmgr_exynos.c
+++ b/src/tbm_bufmgr_exynos.c
@@ -110,6 +110,8 @@ char *target_name()
 #define TBM_EXYNOS_DEBUG(...)
 #endif
 
+#define STRERR_BUFSIZE 128
+
 #define SIZE_ALIGN(value, base) (((value) + ((base) - 1)) & ~((base) - 1))
 #define DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d))
 #define MAX(a, b) ((a) > (b) ? (a) : (b))
@@ -276,10 +278,11 @@ _tgl_get_version(int fd)
 {
        struct tgl_ver_data data;
        int err;
+       char buf[STRERR_BUFSIZE];
 
        err = ioctl(fd, TGL_IOCTL_GET_VERSION, &data);
        if (err) {
-               TBM_EXYNOS_ERROR("error(%s) %s:%d\n", strerror(errno));
+               TBM_EXYNOS_ERROR("error(%s) %s:%d\n", strerror_r(errno, buf, STRERR_BUFSIZE));
                return 0;
        }
 
@@ -294,13 +297,14 @@ _tgl_init(int fd, unsigned int key)
 {
        struct tgl_reg_data data;
        int err;
+       char buf[STRERR_BUFSIZE];
 
        data.key = key;
        data.timeout_ms = 1000;
 
        err = ioctl(fd, TGL_IOCTL_REGISTER, &data);
        if (err) {
-               TBM_EXYNOS_ERROR("error(%s) key:%d\n", strerror(errno), key);
+               TBM_EXYNOS_ERROR("error(%s) key:%d\n", strerror_r(errno, buf, STRERR_BUFSIZE), key);
                return 0;
        }
 
@@ -312,11 +316,12 @@ _tgl_destroy(int fd, unsigned int key)
 {
        struct tgl_reg_data data;
        int err;
+       char buf[STRERR_BUFSIZE];
 
        data.key = key;
        err = ioctl(fd, TGL_IOCTL_UNREGISTER, &data);
        if (err) {
-               TBM_EXYNOS_ERROR("error(%s) key:%d\n", strerror(errno), key);
+               TBM_EXYNOS_ERROR("error(%s) key:%d\n", strerror_r(errno, buf, STRERR_BUFSIZE), key);
                return 0;
        }
 
@@ -329,6 +334,7 @@ _tgl_lock(int fd, unsigned int key, int opt)
        struct tgl_lock_data data;
        enum tgl_type_data tgl_type;
        int err;
+       char buf[STRERR_BUFSIZE];
 
        switch (opt) {
        case TBM_OPTION_READ:
@@ -348,7 +354,7 @@ _tgl_lock(int fd, unsigned int key, int opt)
        err = ioctl(fd, TGL_IOCTL_LOCK, &data);
        if (err) {
                TBM_EXYNOS_ERROR("error(%s) key:%d opt:%d\n",
-                       strerror(errno), key, opt);
+                       strerror_r(errno, buf, STRERR_BUFSIZE), key, opt);
                return 0;
        }
 
@@ -360,6 +366,7 @@ _tgl_unlock(int fd, unsigned int key)
 {
        struct tgl_lock_data data;
        int err;
+       char buf[STRERR_BUFSIZE];
 
        data.key = key;
        data.type = TGL_TYPE_NONE;
@@ -367,7 +374,7 @@ _tgl_unlock(int fd, unsigned int key)
        err = ioctl(fd, TGL_IOCTL_UNLOCK, &data);
        if (err) {
                TBM_EXYNOS_ERROR("error(%s) key:%d\n",
-                       strerror(errno), key);
+                       strerror_r(errno, buf, STRERR_BUFSIZE), key);
                return 0;
        }
 
@@ -379,6 +386,7 @@ _tgl_set_data(int fd, unsigned int key, unsigned int val)
 {
        struct tgl_usr_data data;
        int err;
+       char buf[STRERR_BUFSIZE];
 
        data.key = key;
        data.data1 = val;
@@ -386,7 +394,7 @@ _tgl_set_data(int fd, unsigned int key, unsigned int val)
        err = ioctl(fd, TGL_IOCTL_SET_DATA, &data);
        if (err) {
                TBM_EXYNOS_ERROR("error(%s) key:%d\n",
-                       strerror(errno), key);
+                       strerror_r(errno, buf, STRERR_BUFSIZE), key);
                return 0;
        }
 
@@ -398,13 +406,14 @@ _tgl_get_data(int fd, unsigned int key)
 {
        struct tgl_usr_data data = { 0, };
        int err;
+       char buf[STRERR_BUFSIZE];
 
        data.key = key;
 
        err = ioctl(fd, TGL_IOCTL_GET_DATA, &data);
        if (err) {
                TBM_EXYNOS_ERROR("error(%s) key:%d\n",
-                       strerror(errno), key);
+                       strerror_r(errno, buf, STRERR_BUFSIZE), key);
                return 0;
        }
 
@@ -1100,6 +1109,7 @@ tbm_exynos_bo_free(tbm_bo bo)
 {
        tbm_bo_exynos bo_exynos;
        tbm_bufmgr_exynos bufmgr_exynos;
+       char buf[STRERR_BUFSIZE];
 
        if (!bo)
                return;
@@ -1119,7 +1129,7 @@ tbm_exynos_bo_free(tbm_bo bo)
        if (bo_exynos->pBase) {
                if (munmap(bo_exynos->pBase, bo_exynos->size) == -1) {
                        TBM_EXYNOS_ERROR("bo:%p fail to munmap(%s)\n",
-                                      bo, strerror(errno));
+                                      bo, strerror_r(errno, buf, STRERR_BUFSIZE));
                }
        }
 
@@ -1156,7 +1166,7 @@ tbm_exynos_bo_free(tbm_bo bo)
        arg.handle = bo_exynos->gem;
        if (drmIoctl(bo_exynos->fd, DRM_IOCTL_GEM_CLOSE, &arg)) {
                TBM_EXYNOS_ERROR("bo:%p fail to gem close.(%s)\n",
-                              bo, strerror(errno));
+                              bo, strerror_r(errno, buf, STRERR_BUFSIZE));
        }
 
        free(bo_exynos);
@@ -1267,6 +1277,7 @@ tbm_exynos_bo_import_fd(tbm_bo bo, tbm_fd key)
        PrivGem *privGem = NULL;
        unsigned int name;
        int ret;
+       char buf[STRERR_BUFSIZE];
 
        bufmgr_exynos = (tbm_bufmgr_exynos)tbm_backend_get_bufmgr_priv(bo);
        EXYNOS_RETURN_VAL_IF_FAIL(bufmgr_exynos != NULL, 0);
@@ -1279,7 +1290,7 @@ tbm_exynos_bo_import_fd(tbm_bo bo, tbm_fd key)
        arg.flags = 0;
        if (drmIoctl(bufmgr_exynos->fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &arg)) {
                TBM_EXYNOS_ERROR("bo:%p Cannot get gem handle from fd:%d (%s)\n",
-                              bo, arg.fd, strerror(errno));
+                              bo, arg.fd, strerror_r(errno, buf, STRERR_BUFSIZE));
                return NULL;
        }
        gem = arg.handle;
@@ -1287,7 +1298,7 @@ tbm_exynos_bo_import_fd(tbm_bo bo, tbm_fd key)
        name = _get_name(bufmgr_exynos->fd, gem);
        if (!name) {
                TBM_EXYNOS_ERROR("bo:%p Cannot get name from gem:%d, fd:%d (%s)\n",
-                              bo, gem, key, strerror(errno));
+                              bo, gem, key, strerror_r(errno, buf, STRERR_BUFSIZE));
                return 0;
        }
 
@@ -1314,7 +1325,7 @@ tbm_exynos_bo_import_fd(tbm_bo bo, tbm_fd key)
                                &info,
                                sizeof(struct drm_exynos_gem_info))) {
                TBM_EXYNOS_ERROR("bo:%p Cannot get gem info from gem:%d, fd:%d (%s)\n",
-                              bo, gem, key, strerror(errno));
+                              bo, gem, key, strerror_r(errno, buf, STRERR_BUFSIZE));
                return 0;
        }
 
@@ -1405,6 +1416,7 @@ tbm_exynos_bo_export_fd(tbm_bo bo)
 
        tbm_bo_exynos bo_exynos;
        int ret;
+       char buf[STRERR_BUFSIZE];
 
        bo_exynos = (tbm_bo_exynos)tbm_backend_get_bo_priv(bo);
        EXYNOS_RETURN_VAL_IF_FAIL(bo_exynos != NULL, -1);
@@ -1415,7 +1427,7 @@ tbm_exynos_bo_export_fd(tbm_bo bo)
        ret = drmIoctl(bo_exynos->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &arg);
        if (ret) {
                TBM_EXYNOS_ERROR("bo:%p Cannot dmabuf=%d (%s)\n",
-                              bo, bo_exynos->gem, strerror(errno));
+                              bo, bo_exynos->gem, strerror_r(errno, buf, STRERR_BUFSIZE));
                return (tbm_fd) ret;
        }
 
@@ -1559,6 +1571,7 @@ tbm_exynos_bo_lock(tbm_bo bo, int device, int opt)
        struct dma_buf_fence fence;
        struct flock filelock;
        int ret = 0;
+       char buf[STRERR_BUFSIZE];
 
        if (device != TBM_DEVICE_3D && device != TBM_DEVICE_CPU) {
                TBM_EXYNOS_DEBUG("Not support device type,\n");
@@ -1587,7 +1600,7 @@ tbm_exynos_bo_lock(tbm_bo bo, int device, int opt)
 
        /* Check if the tbm manager supports dma fence or not. */
        if (!bufmgr_exynos->use_dma_fence) {
-               TBM_EXYNOS_ERROR("Not support DMA FENCE(%s)\n", strerror(errno));
+               TBM_EXYNOS_ERROR("Not support DMA FENCE(%s)\n", strerror_r(errno, buf, STRERR_BUFSIZE));
                return 0;
 
        }
@@ -1595,7 +1608,7 @@ tbm_exynos_bo_lock(tbm_bo bo, int device, int opt)
        if (device == TBM_DEVICE_3D) {
                ret = ioctl(bo_exynos->dmabuf, DMABUF_IOCTL_GET_FENCE, &fence);
                if (ret < 0) {
-                       TBM_EXYNOS_ERROR("Cannot set GET FENCE(%s)\n", strerror(errno));
+                       TBM_EXYNOS_ERROR("Cannot set GET FENCE(%s)\n", strerror_r(errno, buf, STRERR_BUFSIZE));
                        return 0;
                }
        } else {
@@ -1653,6 +1666,7 @@ tbm_exynos_bo_unlock(tbm_bo bo)
        struct flock filelock;
        unsigned int dma_type = 0;
        int ret = 0;
+       char buf[STRERR_BUFSIZE];
 
        bo_exynos = (tbm_bo_exynos)tbm_backend_get_bo_priv(bo);
        EXYNOS_RETURN_VAL_IF_FAIL(bo_exynos != NULL, 0);
@@ -1689,7 +1703,7 @@ tbm_exynos_bo_unlock(tbm_bo bo)
        if (dma_type) {
                ret = ioctl(bo_exynos->dmabuf, DMABUF_IOCTL_PUT_FENCE, &fence);
                if (ret < 0) {
-                       TBM_EXYNOS_ERROR("Can not set PUT FENCE(%s)\n", strerror(errno));
+                       TBM_EXYNOS_ERROR("Can not set PUT FENCE(%s)\n", strerror_r(errno, buf, STRERR_BUFSIZE));
                        return 0;
                }
        } else {