sw_sync.c revision 50d0a21b61f22b38f881fa21d2ada6ab4a61f93f
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 28static 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 36struct 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} 47EXPORT_SYMBOL(sw_sync_pt_create); 48 49static 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(sync_pt); 54 55 return (struct sync_pt *)sw_sync_pt_create(obj, pt->value); 56} 57 58static 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(sync_pt); 63 64 return sw_sync_cmp(obj->value, pt->value) >= 0; 65} 66 67static 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 75static 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 88static 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 96static 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 101 snprintf(str, size, "%d", pt->value); 102} 103 104static struct sync_timeline_ops sw_sync_timeline_ops = { 105 .driver_name = "sw_sync", 106 .dup = sw_sync_pt_dup, 107 .has_signaled = sw_sync_pt_has_signaled, 108 .compare = sw_sync_pt_compare, 109 .fill_driver_data = sw_sync_fill_driver_data, 110 .timeline_value_str = sw_sync_timeline_value_str, 111 .pt_value_str = sw_sync_pt_value_str, 112}; 113 114struct 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} 123EXPORT_SYMBOL(sw_sync_timeline_create); 124 125void sw_sync_timeline_inc(struct sw_sync_timeline *obj, u32 inc) 126{ 127 obj->value += inc; 128 129 sync_timeline_signal(&obj->obj); 130} 131EXPORT_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 */ 140static 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 156static int sw_sync_release(struct inode *inode, struct file *file) 157{ 158 struct sw_sync_timeline *obj = file->private_data; 159 160 sync_timeline_destroy(&obj->obj); 161 return 0; 162} 163 164static long sw_sync_ioctl_create_fence(struct sw_sync_timeline *obj, 165 unsigned long arg) 166{ 167 int fd = get_unused_fd_flags(O_CLOEXEC); 168 int err; 169 struct sync_pt *pt; 170 struct sync_fence *fence; 171 struct sw_sync_create_fence_data data; 172 173 if (fd < 0) 174 return fd; 175 176 if (copy_from_user(&data, (void __user *)arg, sizeof(data))) { 177 err = -EFAULT; 178 goto err; 179 } 180 181 pt = sw_sync_pt_create(obj, data.value); 182 if (pt == NULL) { 183 err = -ENOMEM; 184 goto err; 185 } 186 187 data.name[sizeof(data.name) - 1] = '\0'; 188 fence = sync_fence_create(data.name, pt); 189 if (fence == NULL) { 190 sync_pt_free(pt); 191 err = -ENOMEM; 192 goto err; 193 } 194 195 data.fence = fd; 196 if (copy_to_user((void __user *)arg, &data, sizeof(data))) { 197 sync_fence_put(fence); 198 err = -EFAULT; 199 goto err; 200 } 201 202 sync_fence_install(fence, fd); 203 204 return 0; 205 206err: 207 put_unused_fd(fd); 208 return err; 209} 210 211static long sw_sync_ioctl_inc(struct sw_sync_timeline *obj, unsigned long arg) 212{ 213 u32 value; 214 215 if (copy_from_user(&value, (void __user *)arg, sizeof(value))) 216 return -EFAULT; 217 218 sw_sync_timeline_inc(obj, value); 219 220 return 0; 221} 222 223static long sw_sync_ioctl(struct file *file, unsigned int cmd, 224 unsigned long arg) 225{ 226 struct sw_sync_timeline *obj = file->private_data; 227 228 switch (cmd) { 229 case SW_SYNC_IOC_CREATE_FENCE: 230 return sw_sync_ioctl_create_fence(obj, arg); 231 232 case SW_SYNC_IOC_INC: 233 return sw_sync_ioctl_inc(obj, arg); 234 235 default: 236 return -ENOTTY; 237 } 238} 239 240static const struct file_operations sw_sync_fops = { 241 .owner = THIS_MODULE, 242 .open = sw_sync_open, 243 .release = sw_sync_release, 244 .unlocked_ioctl = sw_sync_ioctl, 245 .compat_ioctl = sw_sync_ioctl, 246}; 247 248static struct miscdevice sw_sync_dev = { 249 .minor = MISC_DYNAMIC_MINOR, 250 .name = "sw_sync", 251 .fops = &sw_sync_fops, 252}; 253 254static int __init sw_sync_device_init(void) 255{ 256 return misc_register(&sw_sync_dev); 257} 258 259static void __exit sw_sync_device_remove(void) 260{ 261 misc_deregister(&sw_sync_dev); 262} 263 264module_init(sw_sync_device_init); 265module_exit(sw_sync_device_remove); 266 267#endif /* CONFIG_SW_SYNC_USER */ 268