drivers/base/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/file.h>
  19 #include <linux/fs.h>
  20 #include <linux/miscdevice.h>
  21 #include <linux/module.h>
  22 #include <linux/sw_sync.h>
  23 #include <linux/syscalls.h>
  24 #include <linux/uaccess.h>
  25
  26 static int sw_sync_cmp(u32 a, u32 b)
  27 {
  28         if (a == b)
  29                 return 0;
  30
  31         return ((s32)a - (s32)b) < 0 ? -1 : 1;
  32 }
  33
  34 struct sync_pt *sw_sync_pt_create(struct sw_sync_timeline *obj, u32 value)
  35 {
  36         struct sw_sync_pt *pt;
  37
  38         pt = (struct sw_sync_pt *)
  39                 sync_pt_create(&obj->obj, sizeof(struct sw_sync_pt));
  40
  41         pt->value = value;
  42
  43         return (struct sync_pt *)pt;
  44 }
  45
  46 static struct sync_pt *sw_sync_pt_dup(struct sync_pt *sync_pt)
  47 {
  48         struct sw_sync_pt *pt = (struct sw_sync_pt *) sync_pt;
  49         struct sw_sync_timeline *obj =
  50                 (struct sw_sync_timeline *)sync_pt->parent;
  51
  52         return (struct sync_pt *) sw_sync_pt_create(obj, pt->value);
  53 }
  54
  55 static int sw_sync_pt_has_signaled(struct sync_pt *sync_pt)
  56 {
  57         struct sw_sync_pt *pt = (struct sw_sync_pt *)sync_pt;
  58         struct sw_sync_timeline *obj =
  59                 (struct sw_sync_timeline *)sync_pt->parent;
  60
  61         return sw_sync_cmp(obj->value, pt->value) >= 0;
  62 }
  63
  64 static int sw_sync_pt_compare(struct sync_pt *a, struct sync_pt *b)
  65 {
  66         struct sw_sync_pt *pt_a = (struct sw_sync_pt *)a;
  67         struct sw_sync_pt *pt_b = (struct sw_sync_pt *)b;
  68
  69         return sw_sync_cmp(pt_a->value, pt_b->value);
  70 }
  71
  72 static void sw_sync_print_obj(struct seq_file *s,
  73                               struct sync_timeline *sync_timeline)
  74 {
  75         struct sw_sync_timeline *obj = (struct sw_sync_timeline *)sync_timeline;
  76
  77         seq_printf(s, "%d", obj->value);
  78 }
  79
  80 static void sw_sync_print_pt(struct seq_file *s, struct sync_pt *sync_pt)
  81 {
  82         struct sw_sync_pt *pt = (struct sw_sync_pt *)sync_pt;
  83         struct sw_sync_timeline *obj =
  84                 (struct sw_sync_timeline *)sync_pt->parent;
  85
  86         seq_printf(s, "%d / %d", pt->value, obj->value);
  87 }
  88
  89 static int sw_sync_fill_driver_data(struct sync_pt *sync_pt,
  90                                     void *data, int size)
  91 {
  92         struct sw_sync_pt *pt = (struct sw_sync_pt *)sync_pt;
  93
  94         if (size < sizeof(pt->value))
  95                 return -ENOMEM;
  96
  97         memcpy(data, &pt->value, sizeof(pt->value));
  98
  99         return sizeof(pt->value);
 100 }
 101
 102 struct sync_timeline_ops sw_sync_timeline_ops = {
 103         .driver_name = "sw_sync",
 104         .dup = sw_sync_pt_dup,
 105         .has_signaled = sw_sync_pt_has_signaled,
 106         .compare = sw_sync_pt_compare,
 107         .print_obj = sw_sync_print_obj,
 108         .print_pt = sw_sync_print_pt,
 109         .fill_driver_data = sw_sync_fill_driver_data,
 110 };
 111
 112
 113 struct sw_sync_timeline *sw_sync_timeline_create(const char *name)
 114 {
 115         struct sw_sync_timeline *obj = (struct sw_sync_timeline *)
 116                 sync_timeline_create(&sw_sync_timeline_ops,
 117                                      sizeof(struct sw_sync_timeline),
 118                                      name);
 119
 120         return obj;
 121 }
 122
 123 void sw_sync_timeline_inc(struct sw_sync_timeline *obj, u32 inc)
 124 {
 125         obj->value += inc;
 126
 127         sync_timeline_signal(&obj->obj);
 128 }
 129
 130
 131 #ifdef CONFIG_SW_SYNC_USER
 132 /* *WARNING*
 133  *
 134  * improper use of this can result in deadlocking kernel drivers from userspace.
 135  */
 136
 137 /* opening sw_sync create a new sync obj */
 138 int sw_sync_open(struct inode *inode, struct file *file)
 139 {
 140         struct sw_sync_timeline *obj;
 141         char task_comm[TASK_COMM_LEN];
 142
 143         get_task_comm(task_comm, current);
 144
 145         obj = sw_sync_timeline_create(task_comm);
 146         if (obj == NULL)
 147                 return -ENOMEM;
 148
 149         file->private_data = obj;
 150
 151         return 0;
 152 }
 153
 154 int sw_sync_release(struct inode *inode, struct file *file)
 155 {
 156         struct sw_sync_timeline *obj = file->private_data;
 157         sync_timeline_destroy(&obj->obj);
 158         return 0;
 159 }
 160
 161 long sw_sync_ioctl_create_fence(struct sw_sync_timeline *obj, unsigned long arg)
 162 {
 163         int fd = get_unused_fd();
 164         int err;
 165         struct sync_pt *pt;
 166         struct sync_fence *fence;
 167         struct sw_sync_create_fence_data data;
 168
 169         if (copy_from_user(&data, (void __user *)arg, sizeof(data)))
 170                 return -EFAULT;
 171
 172         pt = sw_sync_pt_create(obj, data.value);
 173         if (pt == NULL) {
 174                 err = -ENOMEM;
 175                 goto err;
 176         }
 177
 178         data.name[sizeof(data.name) - 1] = '\0';
 179         fence = sync_fence_create(data.name, pt);
 180         if (fence == NULL) {
 181                 sync_pt_free(pt);
 182                 err = -ENOMEM;
 183                 goto err;
 184         }
 185
 186         data.fence = fd;
 187         if (copy_to_user((void __user *)arg, &data, sizeof(data))) {
 188                 sync_fence_put(fence);
 189                 err = -EFAULT;
 190                 goto err;
 191         }
 192
 193         sync_fence_install(fence, fd);
 194
 195         return 0;
 196
 197 err:
 198         put_unused_fd(fd);
 199         return err;
 200 }
 201
 202 long sw_sync_ioctl_inc(struct sw_sync_timeline *obj, unsigned long arg)
 203 {
 204         u32 value;
 205
 206         if (copy_from_user(&value, (void __user *)arg, sizeof(value)))
 207                 return -EFAULT;
 208
 209         sw_sync_timeline_inc(obj, value);
 210
 211         return 0;
 212 }
 213
 214 long sw_sync_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 215 {
 216         struct sw_sync_timeline *obj = file->private_data;
 217
 218         switch (cmd) {
 219         case SW_SYNC_IOC_CREATE_FENCE:
 220                 return sw_sync_ioctl_create_fence(obj, arg);
 221
 222         case SW_SYNC_IOC_INC:
 223                 return sw_sync_ioctl_inc(obj, arg);
 224
 225         default:
 226                 return -ENOTTY;
 227         }
 228 }
 229
 230 static const struct file_operations sw_sync_fops = {
 231         .owner = THIS_MODULE,
 232         .open = sw_sync_open,
 233         .release = sw_sync_release,
 234         .unlocked_ioctl = sw_sync_ioctl,
 235 };
 236
 237 static struct miscdevice sw_sync_dev = {
 238         .minor  = MISC_DYNAMIC_MINOR,
 239         .name   = "sw_sync",
 240         .fops   = &sw_sync_fops,
 241 };
 242
 243 int __init sw_sync_device_init(void)
 244 {
 245         return misc_register(&sw_sync_dev);
 246 }
 247
 248 void __exit sw_sync_device_remove(void)
 249 {
 250         misc_deregister(&sw_sync_dev);
 251 }
 252
 253 module_init(sw_sync_device_init);
 254 module_exit(sw_sync_device_remove);
 255
 256 #endif /* CONFIG_SW_SYNC_USER */