drivers/staging/android/sw_sync.c

   1 /*
   2  * drivers/base/sw_sync.c
   3  *
   4  * Copyright (C) 2012 Google, Inc.
   5  *
   6  * This software is licensed under the terms of the GNU General Public
   7  * License version 2, as published by the Free Software Foundation, and
   8  * may be copied, distributed, and modified under those terms.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  */
  16
  17 #include <linux/kernel.h>
  18 #include <linux/export.h>
  19 #include <linux/file.h>
  20 #include <linux/fs.h>
  21 #include <linux/miscdevice.h>
  22 #include <linux/module.h>
  23 #include <linux/syscalls.h>
  24 #include <linux/uaccess.h>
  25
  26 #include "sw_sync.h"
  27
  28 static int sw_sync_cmp(u32 a, u32 b)
  29 {
  30         if (a == b)
  31                 return 0;
  32
  33         return ((s32)a - (s32)b) < 0 ? -1 : 1;
  34 }
  35
  36 struct sync_pt *sw_sync_pt_create(struct sw_sync_timeline *obj, u32 value)
  37 {
  38         struct sw_sync_pt *pt;
  39
  40         pt = (struct sw_sync_pt *)
  41                 sync_pt_create(&obj->obj, sizeof(struct sw_sync_pt));
  42
  43         pt->value = value;
  44
  45         return (struct sync_pt *)pt;
  46 }
  47 EXPORT_SYMBOL(sw_sync_pt_create);
  48
  49 static struct sync_pt *sw_sync_pt_dup(struct sync_pt *sync_pt)
  50 {
  51         struct sw_sync_pt *pt = (struct sw_sync_pt *) sync_pt;
  52         struct sw_sync_timeline *obj =
  53                 (struct sw_sync_timeline *)sync_pt->parent;
  54
  55         return (struct sync_pt *) sw_sync_pt_create(obj, pt->value);
  56 }
  57
  58 static int sw_sync_pt_has_signaled(struct sync_pt *sync_pt)
  59 {
  60         struct sw_sync_pt *pt = (struct sw_sync_pt *)sync_pt;
  61         struct sw_sync_timeline *obj =
  62                 (struct sw_sync_timeline *)sync_pt->parent;
  63
  64         return sw_sync_cmp(obj->value, pt->value) >= 0;
  65 }
  66
  67 static int sw_sync_pt_compare(struct sync_pt *a, struct sync_pt *b)
  68 {
  69         struct sw_sync_pt *pt_a = (struct sw_sync_pt *)a;
  70         struct sw_sync_pt *pt_b = (struct sw_sync_pt *)b;
  71
  72         return sw_sync_cmp(pt_a->value, pt_b->value);
  73 }
  74
  75 static int sw_sync_fill_driver_data(struct sync_pt *sync_pt,
  76                                     void *data, int size)
  77 {
  78         struct sw_sync_pt *pt = (struct sw_sync_pt *)sync_pt;
  79
  80         if (size < sizeof(pt->value))
  81                 return -ENOMEM;
  82
  83         memcpy(data, &pt->value, sizeof(pt->value));
  84
  85         return sizeof(pt->value);
  86 }
  87
  88 static void sw_sync_timeline_value_str(struct sync_timeline *sync_timeline,
  89                                        char *str, int size)
  90 {
  91         struct sw_sync_timeline *timeline =
  92                 (struct sw_sync_timeline *)sync_timeline;
  93         snprintf(str, size, "%d", timeline->value);
  94 }
  95
  96 static void sw_sync_pt_value_str(struct sync_pt *sync_pt,
  97                                        char *str, int size)
  98 {
  99         struct sw_sync_pt *pt = (struct sw_sync_pt *)sync_pt;
 100         snprintf(str, size, "%d", pt->value);
 101 }
 102
 103 static struct sync_timeline_ops sw_sync_timeline_ops = {
 104         .driver_name = "sw_sync",
 105         .dup = sw_sync_pt_dup,
 106         .has_signaled = sw_sync_pt_has_signaled,
 107         .compare = sw_sync_pt_compare,
 108         .fill_driver_data = sw_sync_fill_driver_data,
 109         .timeline_value_str = sw_sync_timeline_value_str,
 110         .pt_value_str = sw_sync_pt_value_str,
 111 };
 112
 113
 114 struct sw_sync_timeline *sw_sync_timeline_create(const char *name)
 115 {
 116         struct sw_sync_timeline *obj = (struct sw_sync_timeline *)
 117                 sync_timeline_create(&sw_sync_timeline_ops,
 118                                      sizeof(struct sw_sync_timeline),
 119                                      name);
 120
 121         return obj;
 122 }
 123 EXPORT_SYMBOL(sw_sync_timeline_create);
 124
 125 void sw_sync_timeline_inc(struct sw_sync_timeline *obj, u32 inc)
 126 {
 127         obj->value += inc;
 128
 129         sync_timeline_signal(&obj->obj);
 130 }
 131 EXPORT_SYMBOL(sw_sync_timeline_inc);
 132
 133 #ifdef CONFIG_SW_SYNC_USER
 134 /* *WARNING*
 135  *
 136  * improper use of this can result in deadlocking kernel drivers from userspace.
 137  */
 138
 139 /* opening sw_sync create a new sync obj */
 140 static int sw_sync_open(struct inode *inode, struct file *file)
 141 {
 142         struct sw_sync_timeline *obj;
 143         char task_comm[TASK_COMM_LEN];
 144
 145         get_task_comm(task_comm, current);
 146
 147         obj = sw_sync_timeline_create(task_comm);
 148         if (obj == NULL)
 149                 return -ENOMEM;
 150
 151         file->private_data = obj;
 152
 153         return 0;
 154 }
 155
 156 static int sw_sync_release(struct inode *inode, struct file *file)
 157 {
 158         struct sw_sync_timeline *obj = file->private_data;
 159         sync_timeline_destroy(&obj->obj);
 160         return 0;
 161 }
 162
 163 static long sw_sync_ioctl_create_fence(struct sw_sync_timeline *obj,
 164                                        unsigned long arg)
 165 {
 166         int fd = get_unused_fd_flags(O_CLOEXEC);
 167         int err;
 168         struct sync_pt *pt;
 169         struct sync_fence *fence;
 170         struct sw_sync_create_fence_data data;
 171
 172         if (fd < 0)
 173                 return fd;
 174
 175         if (copy_from_user(&data, (void __user *)arg, sizeof(data))) {
 176                 err = -EFAULT;
 177                 goto err;
 178         }
 179
 180         pt = sw_sync_pt_create(obj, data.value);
 181         if (pt == NULL) {
 182                 err = -ENOMEM;
 183                 goto err;
 184         }
 185
 186         data.name[sizeof(data.name) - 1] = '\0';
 187         fence = sync_fence_create(data.name, pt);
 188         if (fence == NULL) {
 189                 sync_pt_free(pt);
 190                 err = -ENOMEM;
 191                 goto err;
 192         }
 193
 194         data.fence = fd;
 195         if (copy_to_user((void __user *)arg, &data, sizeof(data))) {
 196                 sync_fence_put(fence);
 197                 err = -EFAULT;
 198                 goto err;
 199         }
 200
 201         sync_fence_install(fence, fd);
 202
 203         return 0;
 204
 205 err:
 206         put_unused_fd(fd);
 207         return err;
 208 }
 209
 210 static long sw_sync_ioctl_inc(struct sw_sync_timeline *obj, unsigned long arg)
 211 {
 212         u32 value;
 213
 214         if (copy_from_user(&value, (void __user *)arg, sizeof(value)))
 215                 return -EFAULT;
 216
 217         sw_sync_timeline_inc(obj, value);
 218
 219         return 0;
 220 }
 221
 222 static long sw_sync_ioctl(struct file *file, unsigned int cmd,
 223                           unsigned long arg)
 224 {
 225         struct sw_sync_timeline *obj = file->private_data;
 226
 227         switch (cmd) {
 228         case SW_SYNC_IOC_CREATE_FENCE:
 229                 return sw_sync_ioctl_create_fence(obj, arg);
 230
 231         case SW_SYNC_IOC_INC:
 232                 return sw_sync_ioctl_inc(obj, arg);
 233
 234         default:
 235                 return -ENOTTY;
 236         }
 237 }
 238
 239 static const struct file_operations sw_sync_fops = {
 240         .owner = THIS_MODULE,
 241         .open = sw_sync_open,
 242         .release = sw_sync_release,
 243         .unlocked_ioctl = sw_sync_ioctl,
 244         .compat_ioctl = sw_sync_ioctl,
 245 };
 246
 247 static struct miscdevice sw_sync_dev = {
 248         .minor  = MISC_DYNAMIC_MINOR,
 249         .name   = "sw_sync",
 250         .fops   = &sw_sync_fops,
 251 };
 252
 253 static int __init sw_sync_device_init(void)
 254 {
 255         return misc_register(&sw_sync_dev);
 256 }
 257
 258 static void __exit sw_sync_device_remove(void)
 259 {
 260         misc_deregister(&sw_sync_dev);
 261 }
 262
 263 module_init(sw_sync_device_init);
 264 module_exit(sw_sync_device_remove);
 265
 266 #endif /* CONFIG_SW_SYNC_USER */