1 /*
2  *  sync / sw_sync abstraction
3  *  Copyright 2015-2016 Collabora Ltd.
4  *
5  *  Based on the implementation from the Android Open Source Project,
6  *
7  *  Copyright 2012 Google, Inc
8  *
9  *  Permission is hereby granted, free of charge, to any person obtaining a
10  *  copy of this software and associated documentation files (the "Software"),
11  *  to deal in the Software without restriction, including without limitation
12  *  the rights to use, copy, modify, merge, publish, distribute, sublicense,
13  *  and/or sell copies of the Software, and to permit persons to whom the
14  *  Software is furnished to do so, subject to the following conditions:
15  *
16  *  The above copyright notice and this permission notice shall be included in
17  *  all copies or substantial portions of the Software.
18  *
19  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20  *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22  *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
23  *  OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
24  *  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
25  *  OTHER DEALINGS IN THE SOFTWARE.
26  */
27 
28 #include <fcntl.h>
29 #include <malloc.h>
30 #include <poll.h>
31 #include <stdint.h>
32 #include <string.h>
33 #include <unistd.h>
34 
35 #include <sys/ioctl.h>
36 #include <sys/stat.h>
37 #include <sys/types.h>
38 
39 #include "sync.h"
40 #include "sw_sync.h"
41 
42 #include <linux/sync_file.h>
43 
44 
45 /* SW_SYNC ioctls */
46 struct sw_sync_create_fence_data {
47 	__u32	value;
48 	char	name[32];
49 	__s32	fence;
50 };
51 
52 #define SW_SYNC_IOC_MAGIC		'W'
53 #define SW_SYNC_IOC_CREATE_FENCE	_IOWR(SW_SYNC_IOC_MAGIC, 0,\
54 					      struct sw_sync_create_fence_data)
55 #define SW_SYNC_IOC_INC			_IOW(SW_SYNC_IOC_MAGIC, 1, __u32)
56 
57 
58 int sync_wait(int fd, int timeout)
59 {
60 	struct pollfd fds;
61 
62 	fds.fd = fd;
63 	fds.events = POLLIN | POLLERR;
64 
65 	return poll(&fds, 1, timeout);
66 }
67 
68 int sync_merge(const char *name, int fd1, int fd2)
69 {
70 	struct sync_merge_data data = {};
71 	int err;
72 
73 	data.fd2 = fd2;
74 	strncpy(data.name, name, sizeof(data.name) - 1);
75 	data.name[sizeof(data.name) - 1] = '\0';
76 
77 	err = ioctl(fd1, SYNC_IOC_MERGE, &data);
78 	if (err < 0)
79 		return err;
80 
81 	return data.fence;
82 }
83 
84 static struct sync_file_info *sync_file_info(int fd)
85 {
86 	struct sync_file_info *info;
87 	struct sync_fence_info *fence_info;
88 	int err, num_fences;
89 
90 	info = calloc(1, sizeof(*info));
91 	if (info == NULL)
92 		return NULL;
93 
94 	err = ioctl(fd, SYNC_IOC_FILE_INFO, info);
95 	if (err < 0) {
96 		free(info);
97 		return NULL;
98 	}
99 
100 	num_fences = info->num_fences;
101 
102 	if (num_fences) {
103 		info->flags = 0;
104 		info->num_fences = num_fences;
105 
106 		fence_info = calloc(num_fences, sizeof(*fence_info));
107 		if (!fence_info) {
108 			free(info);
109 			return NULL;
110 		}
111 
112 		info->sync_fence_info = (uint64_t)fence_info;
113 
114 		err = ioctl(fd, SYNC_IOC_FILE_INFO, info);
115 		if (err < 0) {
116 			free(fence_info);
117 			free(info);
118 			return NULL;
119 		}
120 	}
121 
122 	return info;
123 }
124 
125 static void sync_file_info_free(struct sync_file_info *info)
126 {
127 	free((void *)info->sync_fence_info);
128 	free(info);
129 }
130 
131 int sync_fence_size(int fd)
132 {
133 	int count;
134 	struct sync_file_info *info = sync_file_info(fd);
135 
136 	if (!info)
137 		return 0;
138 
139 	count = info->num_fences;
140 
141 	sync_file_info_free(info);
142 
143 	return count;
144 }
145 
146 int sync_fence_count_with_status(int fd, int status)
147 {
148 	unsigned int i, count = 0;
149 	struct sync_fence_info *fence_info = NULL;
150 	struct sync_file_info *info = sync_file_info(fd);
151 
152 	if (!info)
153 		return -1;
154 
155 	fence_info = (struct sync_fence_info *)info->sync_fence_info;
156 	for (i = 0 ; i < info->num_fences ; i++) {
157 		if (fence_info[i].status == status)
158 			count++;
159 	}
160 
161 	sync_file_info_free(info);
162 
163 	return count;
164 }
165 
166 int sw_sync_timeline_create(void)
167 {
168 	return open("/sys/kernel/debug/sync/sw_sync", O_RDWR);
169 }
170 
171 int sw_sync_timeline_inc(int fd, unsigned int count)
172 {
173 	__u32 arg = count;
174 
175 	return ioctl(fd, SW_SYNC_IOC_INC, &arg);
176 }
177 
178 int sw_sync_timeline_is_valid(int fd)
179 {
180 	int status;
181 
182 	if (fd == -1)
183 		return 0;
184 
185 	status = fcntl(fd, F_GETFD, 0);
186 	return (status >= 0);
187 }
188 
189 void sw_sync_timeline_destroy(int fd)
190 {
191 	if (sw_sync_timeline_is_valid(fd))
192 		close(fd);
193 }
194 
195 int sw_sync_fence_create(int fd, const char *name, unsigned int value)
196 {
197 	struct sw_sync_create_fence_data data = {};
198 	int err;
199 
200 	data.value = value;
201 	strncpy(data.name, name, sizeof(data.name) - 1);
202 	data.name[sizeof(data.name) - 1] = '\0';
203 
204 	err = ioctl(fd, SW_SYNC_IOC_CREATE_FENCE, &data);
205 	if (err < 0)
206 		return err;
207 
208 	return data.fence;
209 }
210 
211 int sw_sync_fence_is_valid(int fd)
212 {
213 	/* Same code! */
214 	return sw_sync_timeline_is_valid(fd);
215 }
216 
217 void sw_sync_fence_destroy(int fd)
218 {
219 	if (sw_sync_fence_is_valid(fd))
220 		close(fd);
221 }
222