src/tbm_sync.c

   1 /**************************************************************************
   2
   3 libtbm
   4
   5 Copyright 2012 - 2016 Samsung Electronics co., Ltd. All Rights Reserved.
   6
   7 Contact: SooChan Lim <sc1.lim@samsung.com>,
   8                  Changyeon Lee <cyeon.lee@samsung.com>,
   9                  Boram Park <boram1288.park@samsung.com>,
  10                  Sangjin Lee <lsj119@samsung.com>
  11
  12 Permission is hereby granted, free of charge, to any person obtaining a
  13 copy of this software and associated documentation files (the
  14 "Software"), to deal in the Software without restriction, including
  15 without limitation the rights to use, copy, modify, merge, publish,
  16 distribute, sub license, and/or sell copies of the Software, and to
  17 permit persons to whom the Software is furnished to do so, subject to
  18 the following conditions:
  19
  20 The above copyright notice and this permission notice (including the
  21 next paragraph) shall be included in all copies or substantial portions
  22 of the Software.
  23
  24 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  25 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  27 IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  28 ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  29 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  30 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  31
  32 **************************************************************************/
  33
  34 #include "config.h"
  35
  36 #include "tbm_bufmgr_int.h"
  37 #include "tbm_sync.h"
  38
  39 #include <string.h>
  40 #include <errno.h>
  41 #include <sys/ioctl.h>
  42 #include <linux/types.h>
  43
  44 /* IOCTLs for timeline file object. */
  45 #define TIMELINE_IOC_MAGIC                      'W'
  46 #define TIMELINE_IOC_CREATE_FENCE       _IOWR(TIMELINE_IOC_MAGIC, 0, struct create_fence_data)
  47 #define TIMELINE_IOC_INC                        _IOW(TIMELINE_IOC_MAGIC, 1, __u32)
  48
  49 /* IOCTLs for fence file object. */
  50 #define FENCE_IOC_MAGIC         '>'
  51 #define FENCE_IOC_WAIT          _IOW(FENCE_IOC_MAGIC, 0, __s32)
  52 #define FENCE_IOC_MERGE         _IOWR(FENCE_IOC_MAGIC, 1, struct sync_merge_data)
  53
  54 /* Path to the sync device file. */
  55 #define SYNC_DEVICE_PATH        "/dev/sw_sync"
  56
  57 /* Argument data structure for the timeline.create_fence ioctl. */
  58 struct create_fence_data {
  59         __u32   value;          /* Pt value on the timeline for the fence (IN) */
  60         char    name[32];       /* Name of the fence object (IN) */
  61         __s32   fence;          /* File descriptor for the created fence (OUT) */
  62 };
  63
  64 /* Argument data structure for the fence.merge ioctl. */
  65 struct sync_merge_data {
  66         __s32   fd2;            /* fence to merged with the fence (IN) */
  67         char    name[32];       /* Name of the new fence object (IN) */
  68         __s32   fence;          /* File descriptor for the new fence (OUT) */
  69 };
  70
  71 #define ERRNO_BUF_SIZE  256
  72
  73 static inline void
  74 _log_errno()
  75 {
  76         /* calling strerror_r() might overwrite errno, so save it. */
  77         int             errnum = errno;
  78         char    buf[ERRNO_BUF_SIZE];
  79
  80         if (strerror_r(errnum, buf, ERRNO_BUF_SIZE) == 0) {
  81                 TBM_LOG_E("errno : %d(%s)\n", errnum, buf);
  82                 return;
  83         } else {
  84                 TBM_LOG_E("errno : %d()\n", errnum);
  85                 return;
  86         }
  87 }
  88
  89 static inline void
  90 _copy_string(char *dst, const char *src, size_t size)
  91 {
  92         if (size == 0)
  93                 return;
  94
  95         if (src == NULL || size == 1) {
  96                 *dst = '\0';
  97                 return;
  98         }
  99
 100         while (size-- != 1) {
 101                 if ((*dst++ = *src++) == '\0')
 102                         return;
 103         }
 104
 105         *dst = '\0';
 106 }
 107
 108 tbm_fd
 109 tbm_sync_timeline_create(void)
 110 {
 111         tbm_fd timeline = open(SYNC_DEVICE_PATH, O_RDWR | O_CLOEXEC);
 112
 113         if (timeline == -1)
 114                 _log_errno();
 115
 116         return timeline;
 117 }
 118
 119 int
 120 tbm_sync_timeline_inc(tbm_fd timeline, unsigned int count)
 121 {
 122         __u32 arg = count;
 123
 124         if (ioctl(timeline, TIMELINE_IOC_INC, &arg) == -1) {
 125                 _log_errno();
 126                 return 0;
 127         }
 128
 129         return 1;
 130 }
 131
 132 tbm_fd
 133 tbm_sync_fence_create(tbm_fd timeline, const char *name, unsigned int value)
 134 {
 135         struct create_fence_data data = { .value = value };
 136
 137         _copy_string(data.name, name, 32);
 138
 139         if (ioctl(timeline, TIMELINE_IOC_CREATE_FENCE, &data) == -1) {
 140                 _log_errno();
 141                 return -1;
 142         }
 143
 144         return data.fence;
 145 }
 146
 147 int
 148 tbm_sync_fence_wait(tbm_fd fence, int timeout)
 149 {
 150         __s32   arg = timeout;
 151         int             ret;
 152
 153         /* Retry while ioctl() ended up with interrupt. */
 154         do {
 155                 ret = ioctl(fence, FENCE_IOC_WAIT, &arg);
 156         } while (ret == -1 && errno == EINTR);
 157
 158         /* ioctl() was successful. */
 159         if (ret == 0)
 160                 return 1;
 161
 162         /* ioctl() ended up with timeout. */
 163         if (errno == ETIME)
 164                 return -1;
 165
 166         /* ioctl() failed for some reason. */
 167         _log_errno();
 168         return 0;
 169 }
 170
 171 tbm_fd
 172 tbm_sync_fence_merge(const char *name, tbm_fd fence1, tbm_fd fence2)
 173 {
 174         struct sync_merge_data data = { .fd2 = fence2 };
 175
 176         _copy_string(data.name, name, 32);
 177
 178         if (ioctl(fence1, FENCE_IOC_MERGE, &data) == -1) {
 179                 _log_errno();
 180                 return -1;
 181         }
 182
 183         return data.fence;
 184 }