source: libcfa/src/concurrency/io/call.cfa.in@ d2fadeb

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since d2fadeb was 57b3675, checked in by Thierry Delisle <tdelisle@…>, 5 years ago

Fix warnings in io implementation.
  • Property mode set to 100644
File size: 13.5 KB
Line 
1#!python3
2#
3# Cforall Version 1.0.0 Copyright (C) 2020 University of Waterloo
4#
5# The contents of this file are covered under the licence agreement in the
6# file "LICENCE" distributed with Cforall.
7#
8# call.cfa.in -- Python script to generate io/call.cfa
9#
10# Author : Thierry Delisle
11# Created On : Fri Sep 11 12:41:16 2020
12# Last Modified By :
13# Last Modified On :
14# Update Count :
15#
16
17Header = """//
18// Cforall Version 1.0.0 Copyright (C) 2020 University of Waterloo
19//
20// The contents of this file are covered under the licence agreement in the
21// file "LICENCE" distributed with Cforall.
22//
23// call.cfa -- Api for cforall
24//
25// Author : Generated from call.cfa.in
26// Created On : {}
27//
28
29"""
30
31Prelude = """#define __cforall_thread__
32
33#include "bits/defs.hfa"
34#include "kernel.hfa"
35#include "io/types.hfa"
36
37//=============================================================================================
38// I/O uring backend
39//=============================================================================================
40
41#if defined(CFA_HAVE_LINUX_IO_URING_H)
42 #include <assert.h>
43 #include <stdint.h>
44 #include <errno.h>
45 #include <linux/io_uring.h>
46
47 #include "kernel/fwd.hfa"
48
49 static const __u8 REGULAR_FLAGS = 0
50 #if defined(CFA_HAVE_IOSQE_FIXED_FILE)
51 | IOSQE_FIXED_FILE
52 #endif
53 #if defined(CFA_HAVE_IOSQE_IO_DRAIN)
54 | IOSQE_IO_DRAIN
55 #endif
56 #if defined(CFA_HAVE_IOSQE_IO_LINK)
57 | IOSQE_IO_LINK
58 #endif
59 #if defined(CFA_HAVE_IOSQE_IO_HARDLINK)
60 | IOSQE_IO_HARDLINK
61 #endif
62 #if defined(CFA_HAVE_IOSQE_ASYNC)
63 | IOSQE_ASYNC
64 #endif
65 #if defined(CFA_HAVE_IOSQE_BUFFER_SELECTED)
66 | IOSQE_BUFFER_SELECTED
67 #endif
68 ;
69
70 static const __u32 SPLICE_FLAGS = 0
71 #if defined(CFA_HAVE_SPLICE_F_FD_IN_FIXED)
72 | SPLICE_F_FD_IN_FIXED
73 #endif
74 ;
75
76 extern struct $io_context * cfa_io_allocate(struct io_uring_sqe * out_sqes[], __u32 out_idxs[], __u32 want) __attribute__((nonnull (1,2)));
77 extern void cfa_io_submit( struct $io_context * in_ctx, __u32 in_idxs[], __u32 have, bool lazy ) __attribute__((nonnull (1,2)));
78#endif
79
80//=============================================================================================
81// I/O Forwards
82//=============================================================================================
83#include <time.hfa>
84
85// Some forward declarations
86#include <errno.h>
87#include <unistd.h>
88
89extern "C" {
90 #include <asm/types.h>
91 #include <sys/socket.h>
92 #include <sys/syscall.h>
93
94#if defined(CFA_HAVE_PREADV2)
95 struct iovec;
96 extern ssize_t preadv2 (int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
97#endif
98#if defined(CFA_HAVE_PWRITEV2)
99 struct iovec;
100 extern ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
101#endif
102
103 extern int fsync(int fd);
104
105 #if __OFF_T_MATCHES_OFF64_T
106 typedef __off64_t off_t;
107 #else
108 typedef __off_t off_t;
109 #endif
110 typedef __off64_t off64_t;
111 extern int sync_file_range(int fd, off64_t offset, off64_t nbytes, unsigned int flags);
112
113 struct msghdr;
114 struct sockaddr;
115 extern ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
116 extern ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
117 extern ssize_t send(int sockfd, const void *buf, size_t len, int flags);
118 extern ssize_t recv(int sockfd, void *buf, size_t len, int flags);
119 extern int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
120 extern int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
121
122 extern int fallocate(int fd, int mode, off_t offset, off_t len);
123 extern int posix_fadvise(int fd, off_t offset, off_t len, int advice);
124 extern int madvise(void *addr, size_t length, int advice);
125
126 extern int openat(int dirfd, const char *pathname, int flags, mode_t mode);
127 extern int close(int fd);
128
129 extern ssize_t read (int fd, void *buf, size_t count);
130
131 struct epoll_event;
132 extern int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
133
134 extern ssize_t splice(int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags);
135 extern ssize_t tee(int fd_in, int fd_out, size_t len, unsigned int flags);
136}
137
138//=============================================================================================
139// I/O Interface
140//=============================================================================================
141"""
142
143print(Header.format("A Date"))
144print(Prelude)
145
146import re
147import sys
148class Call:
149 def __init__(self, op, signature, body, define=None):
150 sig = re.search("(.*) (.*)\((.*)\)", signature)
151 if not sig:
152 print("OP '{}' has invalid signature {}".format(op, signature), file=sys.stderr)
153 sys.exit(1)
154
155 self.op = op
156 self.ret = sig.group(1)
157 self.name = sig.group(2)
158 self.params = sig.group(3)
159 self.define = define
160 self.body = ""
161
162 accepted_keys = [ 'ioprio', 'fd', 'off', 'addr2','addr', 'splice_off_in','len',
163 'rw_flags', 'fsync_flags', 'poll_events', 'poll32_events',
164 'sync_range_flags', 'msg_flags', 'timeout_flags', 'accept_flags',
165 'cancel_flags', 'open_flags', 'statx_flags', 'fadvise_advice',
166 'splice_flags', 'buf_index' ,'buf_group' 'personality',
167 'splice_fd_in' ]
168
169 for k, v in body.items():
170 if not k in accepted_keys:
171 print("OP '{}' has invalid body kew {}".format(op, k), file=sys.stderr)
172 sys.exit(1)
173
174 self.body += "\n sqe->{key} = {value};".format(key=k, value=v)
175
176
177 def args(self):
178 param_a = self.params.split(',')
179 args_a = [p.replace('*', ' ').split()[-1] for p in param_a]
180 for a in args_a:
181 if '*' in a:
182 print("OP '{}' has invalid * in argument {}".format(self.op, a), file=sys.stderr)
183 sys.exit(1)
184
185 return ', '.join(args_a)
186
187AsyncTemplate = """inline void async_{name}(io_future_t & future, {params}, __u64 submit_flags) {{
188 #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_{op})
189 ssize_t res = {name}({args});
190 if (res >= 0) {{
191 fulfil(future, res);
192 }}
193 else {{
194 fulfil(future, -errno);
195 }}
196 #else
197 __u8 sflags = REGULAR_FLAGS & submit_flags;
198 __u32 idx;
199 struct io_uring_sqe * sqe;
200 struct $io_context * ctx = cfa_io_allocate( &sqe, &idx, 1 );
201
202 sqe->opcode = IORING_OP_{op};
203 sqe->user_data = (uintptr_t)&future;
204 sqe->flags = sflags;
205 sqe->ioprio = 0;
206 sqe->fd = 0;
207 sqe->off = 0;
208 sqe->addr = 0;
209 sqe->len = 0;
210 sqe->fsync_flags = 0;
211 sqe->__pad2[0] = 0;
212 sqe->__pad2[1] = 0;
213 sqe->__pad2[2] = 0;{body}
214
215 asm volatile("": : :"memory");
216
217 verify( sqe->user_data == (uintptr_t)&future );
218 cfa_io_submit( ctx, &idx, 1, 0 != (submit_flags & CFA_IO_LAZY) );
219 #endif
220}}"""
221
222SyncTemplate = """{ret} cfa_{name}({params}, __u64 submit_flags) {{
223 io_future_t future;
224
225 async_{name}( future, {args}, submit_flags );
226
227 wait( future );
228 if( future.result < 0 ) {{
229 errno = -future.result;
230 return -1;
231 }}
232 return future.result;
233}}"""
234
235calls = [
236 # CFA_HAVE_IORING_OP_READV
237 Call('READV', 'ssize_t preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags)', {
238 'fd' : 'fd',
239 'off' : 'offset',
240 'addr': '(uintptr_t)iov',
241 'len' : 'iovcnt',
242 }, define = 'CFA_HAVE_PREADV2'),
243 # CFA_HAVE_IORING_OP_WRITEV
244 Call('WRITEV', 'ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags)', {
245 'fd' : 'fd',
246 'off' : 'offset',
247 'addr': '(uintptr_t)iov',
248 'len' : 'iovcnt'
249 }, define = 'CFA_HAVE_PWRITEV2'),
250 # CFA_HAVE_IORING_OP_FSYNC
251 Call('FSYNC', 'int fsync(int fd)', {
252 'fd': 'fd'
253 }),
254 # CFA_HAVE_IORING_OP_EPOLL_CTL
255 Call('EPOLL_CTL', 'int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)', {
256 'fd': 'epfd',
257 'addr': 'fd',
258 'len': 'op',
259 'off': '(uintptr_t)event'
260 }),
261 # CFA_HAVE_IORING_OP_SYNC_FILE_RANGE
262 Call('SYNC_FILE_RANGE', 'int sync_file_range(int fd, off64_t offset, off64_t nbytes, unsigned int flags)', {
263 'fd': 'fd',
264 'off': 'offset',
265 'len': 'nbytes',
266 'sync_range_flags': 'flags'
267 }),
268 # CFA_HAVE_IORING_OP_SENDMSG
269 Call('SENDMSG', 'ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags)', {
270 'fd': 'sockfd',
271 'addr': '(uintptr_t)(struct msghdr *)msg',
272 'len': '1',
273 'msg_flags': 'flags'
274 }),
275 # CFA_HAVE_IORING_OP_RECVMSG
276 Call('RECVMSG', 'ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags)', {
277 'fd': 'sockfd',
278 'addr': '(uintptr_t)(struct msghdr *)msg',
279 'len': '1',
280 'msg_flags': 'flags'
281 }),
282 # CFA_HAVE_IORING_OP_SEND
283 Call('SEND', 'ssize_t send(int sockfd, const void *buf, size_t len, int flags)', {
284 'fd': 'sockfd',
285 'addr': '(uintptr_t)buf',
286 'len': 'len',
287 'msg_flags': 'flags'
288 }),
289 # CFA_HAVE_IORING_OP_RECV
290 Call('RECV', 'ssize_t recv(int sockfd, void *buf, size_t len, int flags)', {
291 'fd': 'sockfd',
292 'addr': '(uintptr_t)buf',
293 'len': 'len',
294 'msg_flags': 'flags'
295 }),
296 # CFA_HAVE_IORING_OP_ACCEPT
297 Call('ACCEPT', 'int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags)', {
298 'fd': 'sockfd',
299 'addr': '(uintptr_t)addr',
300 'addr2': '(uintptr_t)addrlen',
301 'accept_flags': 'flags'
302 }),
303 # CFA_HAVE_IORING_OP_CONNECT
304 Call('CONNECT', 'int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)', {
305 'fd': 'sockfd',
306 'addr': '(uintptr_t)addr',
307 'off': 'addrlen'
308 }),
309 # CFA_HAVE_IORING_OP_FALLOCATE
310 Call('FALLOCATE', 'int fallocate(int fd, int mode, off_t offset, off_t len)', {
311 'fd': 'fd',
312 'addr': '(uintptr_t)len',
313 'len': 'mode',
314 'off': 'offset'
315 }),
316 # CFA_HAVE_IORING_OP_FADVISE
317 Call('FADVISE', 'int posix_fadvise(int fd, off_t offset, off_t len, int advice)', {
318 'fd': 'fd',
319 'off': 'offset',
320 'len': 'len',
321 'fadvise_advice': 'advice'
322 }),
323 # CFA_HAVE_IORING_OP_MADVISE
324 Call('MADVISE', 'int madvise(void *addr, size_t length, int advice)', {
325 'addr': '(uintptr_t)addr',
326 'len': 'length',
327 'fadvise_advice': 'advice'
328 }),
329 # CFA_HAVE_IORING_OP_OPENAT
330 Call('OPENAT', 'int openat(int dirfd, const char *pathname, int flags, mode_t mode)', {
331 'fd': 'dirfd',
332 'addr': '(uintptr_t)pathname',
333 'len': 'mode',
334 'open_flags': 'flags;'
335 }),
336 # CFA_HAVE_IORING_OP_OPENAT2
337 Call('OPENAT2', 'int openat2(int dirfd, const char *pathname, struct open_how * how, size_t size)', {
338 'fd': 'dirfd',
339 'addr': 'pathname',
340 'len': 'sizeof(*how)',
341 'off': '(uintptr_t)how',
342 }, define = 'CFA_HAVE_OPENAT2'),
343 # CFA_HAVE_IORING_OP_CLOSE
344 Call('CLOSE', 'int close(int fd)', {
345 'fd': 'fd'
346 }),
347 # CFA_HAVE_IORING_OP_STATX
348 Call('STATX', 'int statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf)', {
349 'fd': 'dirfd',
350 'off': '(uintptr_t)statxbuf',
351 'addr': 'pathname',
352 'len': 'mask',
353 'statx_flags': 'flags'
354 }, define = 'CFA_HAVE_STATX'),
355 # CFA_HAVE_IORING_OP_READ
356 Call('READ', 'ssize_t read(int fd, void * buf, size_t count)', {
357 'fd': 'fd',
358 'addr': '(uintptr_t)buf',
359 'len': 'count'
360 }),
361 # CFA_HAVE_IORING_OP_WRITE
362 Call('WRITE', 'ssize_t write(int fd, void * buf, size_t count)', {
363 'fd': 'fd',
364 'addr': '(uintptr_t)buf',
365 'len': 'count'
366 }),
367 # CFA_HAVE_IORING_OP_SPLICE
368 Call('SPLICE', 'ssize_t splice(int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags)', {
369 'splice_fd_in': 'fd_in',
370 'splice_off_in': 'off_in ? (__u64)*off_in : (__u64)-1',
371 'fd': 'fd_out',
372 'off': 'off_out ? (__u64)*off_out : (__u64)-1',
373 'len': 'len',
374 'splice_flags': 'flags'
375 }),
376 # CFA_HAVE_IORING_OP_TEE
377 Call('TEE', 'ssize_t tee(int fd_in, int fd_out, size_t len, unsigned int flags)', {
378 'splice_fd_in': 'fd_in',
379 'fd': 'fd_out',
380 'len': 'len',
381 'splice_flags': 'flags'
382 })
383]
384
385print("//----------")
386print("// synchronous calls")
387for c in calls:
388 if c.define:
389 print("""#if defined({define})
390 {ret} cfa_{name}({params}, __u64 submit_flags);
391#endif""".format(define=c.define,ret=c.ret, name=c.name, params=c.params))
392 else:
393 print("{ret} cfa_{name}({params}, __u64 submit_flags);"
394 .format(ret=c.ret, name=c.name, params=c.params))
395
396print("\n//----------")
397print("// asynchronous calls")
398for c in calls:
399 if c.define:
400 print("""#if defined({define})
401 void async_{name}(io_future_t & future, {params}, __u64 submit_flags);
402#endif""".format(define=c.define,name=c.name, params=c.params))
403 else:
404 print("void async_{name}(io_future_t & future, {params}, __u64 submit_flags);"
405 .format(name=c.name, params=c.params))
406print("\n")
407
408for c in calls:
409 print("//-----------------------------------------------------------------------------")
410 print("// {}".format(c.name))
411 Async = AsyncTemplate.format(
412 name = c.name,
413 ret = c.ret,
414 params = c.params,
415 args = c.args(),
416 op = c.op,
417 body = c.body
418
419 )
420 Sync = SyncTemplate.format(
421 name = c.name,
422 ret = c.ret,
423 params = c.params,
424 args = c.args()
425 )
426
427 if c.define:
428 print("""#if defined({})
429 //----------
430 // asynchronous call
431 {}
432
433 //----------
434 // synchronous call
435 {}
436#endif
437""".format(c.define, "\n\t".join( Async.splitlines() ), "\n\t".join( Sync.splitlines() )))
438 else :
439 print("""//----------
440// asynchronous call
441{}
442
443//----------
444// synchronous call
445{}
446""".format(Async, Sync))
447
448print("""
449//-----------------------------------------------------------------------------
450// Check if a function is has asynchronous
451bool has_user_level_blocking( fptr_t func ) {
452 #if defined(CFA_HAVE_LINUX_IO_URING_H)""")
453
454for c in calls:
455 if c.define:
456 print(""" #if defined({define})
457 if( /*func == (fptr_t)preadv2 || */
458 func == (fptr_t)cfa_{name} ||
459 func == (fptr_t)async_{name} ) {{
460 #if defined(CFA_HAVE_IORING_OP_{op})
461 return true;
462 #else
463 return false;
464 #endif
465 }}
466 #endif""".format(define=c.define, name=c.name, op=c.op))
467 else:
468 print(""" if( /*func == (fptr_t)preadv2 || */
469 func == (fptr_t)cfa_{name} ||
470 func == (fptr_t)async_{name} ) {{
471 #if defined(CFA_HAVE_IORING_OP_{op})
472 return true;
473 #else
474 return false;
475 #endif
476 }}""".format(name=c.name, op=c.op))
477
478print(""" #endif
479
480 return false;
481}""")
Note: See TracBrowser for help on using the repository browser.