Commit acb8e0fa394de15c5a1b1ef20c8498c0b7b3111c | lib/zig/sys-linux

author	Meghan Denny <hello@nektro.net> 2025-04-20 16:22:27 -07:00
committer	Meghan Denny <hello@nektro.net> 2025-04-20 16:22:27 -07:00
log	acb8e0fa394de15c5a1b1ef20c8498c0b7b3111c
tree	af456f064b1149ce67a3668833dd962818b30dcf
parent	0fcaa4555d9099b536e43cc7070399433d52991a

add todos so the symbols show up in autocomplete

1 files changed, 346 insertions(+), 0 deletions(-)

mod.zig+346

...	...	@@ -40,1258 +40,1572 @@ pub fn write(fd: c_int, buf: []const u8) errno.Error!usize {
40	40	// open
41	41	// int open(const char pathname, int flags, ... / mode_t mode */ );
42	42	// asmlinkage long sys_open(const char __user *filename, int flags, umode_t mode);
	43	pub const open = @compileError("TODO: open");
43	44
44	45	// close
45	46	// int close(int fd);
46	47	// asmlinkage long sys_close(unsigned int fd);
	48	pub const close = @compileError("TODO: close");
47	49
48	50	// stat
49	51	// int stat(const char restrict pathname, struct stat restrict statbuf);
50	52	// asmlinkage long sys_stat(const char __user filename, struct __old_kernel_stat __user statbuf);
	53	pub const stat = @compileError("TODO: stat");
51	54
52	55	// fstat
53	56	// int fstat(int fd, struct stat *statbuf);
54	57	// asmlinkage long sys_fstat(unsigned int fd, struct __old_kernel_stat __user *statbuf);
	58	pub const fstat = @compileError("TODO: fstat");
55	59
56	60	// lstat
57	61	// int lstat(const char restrict pathname, struct stat restrict statbuf);
58	62	// asmlinkage long sys_lstat(const char __user filename, struct __old_kernel_stat __user statbuf);
	63	pub const lstat = @compileError("TODO: lstat");
59	64
60	65	// poll
61	66	// int poll(struct pollfd *fds, nfds_t nfds, int timeout);
62	67	// asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds, int timeout);
	68	pub const poll = @compileError("TODO: poll");
63	69
64	70	// lseek
65	71	// off_t lseek(int fd, off_t offset, int whence);
66	72	// asmlinkage long sys_lseek(unsigned int fd, off_t offset, unsigned int whence);
	73	pub const lseek = @compileError("TODO: lseek");
67	74
68	75	// mmap
69	76	// void *mmap(void addr[.length], size_t length, int prot, int flags, int fd, off_t offset);
70	77	// asmlinkage long sys_mmap(unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long fd, unsigned long off);
	78	pub const mmap = @compileError("TODO: mmap");
71	79
72	80	// mprotect
73	81	// int mprotect(void addr[.len], size_t len, int prot);
74	82	// asmlinkage long sys_mprotect(unsigned long start, size_t len, unsigned long prot);
	83	pub const mprotect = @compileError("TODO: mprotect");
75	84
76	85	// munmap
77	86	// int munmap(void addr[.length], size_t length);
78	87	// asmlinkage long sys_munmap(unsigned long addr, size_t len);
	88	pub const munmap = @compileError("TODO: munmap");
79	89
80	90	// brk
81	91	// int brk(void *addr);
82	92	// asmlinkage long sys_brk(unsigned long brk);
	93	pub const brk = @compileError("TODO: brk");
83	94
84	95	// rt_sigaction
85	96	// int sigaction(int signum, const struct sigaction _Nullable restrict act, struct sigaction _Nullable restrict oldact);
86	97	// asmlinkage long sys_rt_sigaction(int, const struct sigaction __user , struct sigaction __user , size_t);
	98	pub const rt_sigaction = @compileError("TODO: rt_sigaction");
87	99
88	100	// rt_sigprocmask
89	101	// int sigprocmask(int how, const sigset_t _Nullable restrict set, sigset_t _Nullable restrict oldset);
90	102	// asmlinkage long sys_rt_sigprocmask(int how, sigset_t __user set, sigset_t __user oset, size_t sigsetsize);
	103	pub const rt_sigprocmask = @compileError("TODO: rt_sigprocmask");
91	104
92	105	// rt_sigreturn
93	106	// int sigreturn(...);
94	107	// asmlinkage long sys_rt_sigreturn(struct pt_regs *regs);
	108	pub const rt_sigreturn = @compileError("TODO: rt_sigreturn");
95	109
96	110	// ioctl
97	111	// int ioctl(int fd, unsigned long op, ...);
98	112	// asmlinkage long sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg);
	113	pub const ioctl = @compileError("TODO: ioctl");
99	114
100	115	// pread64
101	116	// ssize_t pread(int fd, void buf[.count], size_t count, off_t offset);
102	117	// asmlinkage long sys_pread64(unsigned int fd, char __user *buf, size_t count, loff_t pos);
	118	pub const pread64 = @compileError("TODO: pread64");
103	119
104	120	// pwrite64
105	121	// ssize_t pwrite(int fd, const void buf[.count], size_t count, off_t offset);
106	122	// asmlinkage long sys_pwrite64(unsigned int fd, const char __user *buf, size_t count, loff_t pos);
	123	pub const pwrite64 = @compileError("TODO: pwrite64");
107	124
108	125	// readv
109	126	// ssize_t readv(int fd, const struct iovec *iov, int iovcnt);
110	127	// asmlinkage long sys_readv(unsigned long fd, const struct iovec __user *vec, unsigned long vlen);
	128	pub const readv = @compileError("TODO: readv");
111	129
112	130	// writev
113	131	// ssize_t writev(int fd, const struct iovec *iov, int iovcnt);
114	132	// asmlinkage long sys_writev(unsigned long fd, const struct iovec __user *vec, unsigned long vlen);
	133	pub const writev = @compileError("TODO: writev");
115	134
116	135	// access
117	136	// int access(const char *pathname, int mode);
118	137	// asmlinkage long sys_access(const char __user *filename, int mode);
	138	pub const access = @compileError("TODO: access");
119	139
120	140	// pipe
121	141	// int pipe(int pipefd[2]);
122	142	// asmlinkage long sys_pipe(int __user *fildes);
	143	pub const pipe = @compileError("TODO: pipe");
123	144
124	145	// select
125	146	// int select(int nfds, fd_set _Nullable restrict readfds, fd_set _Nullable restrict writefds, fd_set _Nullable restrict exceptfds, struct timeval _Nullable restrict timeout);
126	147	// asmlinkage long sys_select(int n, fd_set __user inp, fd_set __user outp, fd_set __user exp, struct __kernel_old_timeval __user tvp);
	148	pub const select = @compileError("TODO: select");
127	149
128	150	// sched_yield
129	151	// int sched_yield(void);
130	152	// asmlinkage long sys_sched_yield(void);
	153	pub const sched_yield = @compileError("TODO: sched_yield");
131	154
132	155	// mremap
133	156	// void mremap(void old_address[.old_size], size_t old_size, size_t new_size, int flags, ... / void new_address /);
134	157	// asmlinkage long sys_mremap(unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags, unsigned long new_addr);
	158	pub const mremap = @compileError("TODO: mremap");
135	159
136	160	// msync
137	161	// int msync(void addr[.length], size_t length, int flags);
138	162	// asmlinkage long sys_msync(unsigned long start, size_t len, int flags);
	163	pub const msync = @compileError("TODO: msync");
139	164
140	165	// mincore
141	166	// int mincore(void addr[.length], size_t length, unsigned char *vec);
142	167	// asmlinkage long sys_mincore(unsigned long start, size_t len, unsigned char __user * vec);
	168	pub const mincore = @compileError("TODO: mincore");
143	169
144	170	// madvise
145	171	// int madvise(void addr[.length], size_t length, int advice);
146	172	// asmlinkage long sys_madvise(unsigned long start, size_t len, int behavior);
	173	pub const madvise = @compileError("TODO: madvise");
147	174
148	175	// shmget
149	176	// int shmget(key_t key, size_t size, int shmflg);
150	177	// asmlinkage long sys_shmget(key_t key, size_t size, int flag);
	178	pub const shmget = @compileError("TODO: shmget");
151	179
152	180	// shmat
153	181	// void shmat(int shmid, const void _Nullable shmaddr, int shmflg);
154	182	// asmlinkage long sys_shmat(int shmid, char __user *shmaddr, int shmflg);
	183	pub const shmat = @compileError("TODO: shmat");
155	184
156	185	// shmctl
157	186	// int shmctl(int shmid, int op, struct shmid_ds *buf);
158	187	// asmlinkage long sys_shmctl(int shmid, int cmd, struct shmid_ds __user *buf);
	188	pub const shmctl = @compileError("TODO: shmctl");
159	189
160	190	// dup
161	191	// int dup(int oldfd);
162	192	// asmlinkage long sys_dup(unsigned int fildes);
	193	pub const dup = @compileError("TODO: dup");
163	194
164	195	// dup2
165	196	// int dup2(int oldfd, int newfd);
166	197	// asmlinkage long sys_dup2(unsigned int oldfd, unsigned int newfd);
	198	pub const dup2 = @compileError("TODO: dup2");
167	199
168	200	// pause
169	201	// int pause(void);
170	202	// asmlinkage long sys_pause(void);
	203	pub const pause = @compileError("TODO: pause");
171	204
172	205	// nanosleep
173	206	// int nanosleep(const struct timespec duration, struct timespec _Nullable rem);
174	207	// asmlinkage long sys_nanosleep(struct __kernel_timespec __user rqtp, struct __kernel_timespec __user rmtp);
	208	pub const nanosleep = @compileError("TODO: nanosleep");
175	209
176	210	// getitimer
177	211	// int getitimer(int which, struct itimerval *curr_value);
178	212	// asmlinkage long sys_getitimer(int which, struct __kernel_old_itimerval __user *value);
	213	pub const getitimer = @compileError("TODO: getitimer");
179	214
180	215	// alarm
181	216	// unsigned int alarm(unsigned int seconds);
182	217	// asmlinkage long sys_alarm(unsigned int seconds);
	218	pub const alarm = @compileError("TODO: alarm");
183	219
184	220	// setitimer
185	221	// int setitimer(int which, const struct itimerval restrict new_value, struct itimerval _Nullable restrict old_value);
186	222	// asmlinkage long sys_setitimer(int which, struct __kernel_old_itimerval __user value, struct __kernel_old_itimerval __user ovalue);
	223	pub const setitimer = @compileError("TODO: setitimer");
187	224
188	225	// getpid
189	226	// pid_t getpid(void);
190	227	// asmlinkage long sys_getpid(void);
	228	pub const getpid = @compileError("TODO: getpid");
191	229
192	230	// sendfile
193	231	// ssize_t sendfile(int out_fd, int in_fd, off_t *_Nullable offset, size_t count);
194	232	// asmlinkage long sys_sendfile(int out_fd, int in_fd, off_t __user *offset, size_t count);
	233	pub const sendfile = @compileError("TODO: sendfile");
195	234
196	235	// socket
197	236	// int socket(int domain, int type, int protocol);
198	237	// asmlinkage long sys_socket(int, int, int);
	238	pub const socket = @compileError("TODO: socket");
199	239
200	240	// connect
201	241	// int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
202	242	// asmlinkage long sys_connect(int, struct sockaddr __user *, int);
	243	pub const connect = @compileError("TODO: connect");
203	244
204	245	// accept
205	246	// int accept(int sockfd, struct sockaddr _Nullable restrict addr, socklen_t _Nullable restrict addrlen);
206	247	// asmlinkage long sys_accept(int, struct sockaddr __user , int __user );
	248	pub const accept = @compileError("TODO: accept");
207	249
208	250	// sendto
209	251	// ssize_t sendto(int sockfd, const void buf[.len], size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
210	252	// asmlinkage long sys_sendto(int, void __user , size_t, unsigned, struct sockaddr __user , int);
	253	pub const sendto = @compileError("TODO: sendto");
211	254
212	255	// recvfrom
213	256	// ssize_t recvfrom(int sockfd, void buf[restrict .len], size_t len, int flags, struct sockaddr _Nullable restrict src_addr, socklen_t _Nullable restrict addrlen);
214	257	// asmlinkage long sys_recvfrom(int, void __user , size_t, unsigned, struct sockaddr __user , int __user *);
	258	pub const recvfrom = @compileError("TODO: recvfrom");
215	259
216	260	// sendmsg
217	261	// ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
218	262	// asmlinkage long sys_sendmsg(int fd, struct user_msghdr __user *msg, unsigned flags);
	263	pub const sendmsg = @compileError("TODO: sendmsg");
219	264
220	265	// recvmsg
221	266	// ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
222	267	// asmlinkage long sys_recvmsg(int fd, struct user_msghdr __user *msg, unsigned flags);
	268	pub const recvmsg = @compileError("TODO: recvmsg");
223	269
224	270	// shutdown
225	271	// int shutdown(int sockfd, int how);
226	272	// asmlinkage long sys_shutdown(int, int);
	273	pub const shutdown = @compileError("TODO: shutdown");
227	274
228	275	// bind
229	276	// int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
230	277	// asmlinkage long sys_bind(int, struct sockaddr __user *, int);
	278	pub const bind = @compileError("TODO: bind");
231	279
232	280	// listen
233	281	// int listen(int sockfd, int backlog);
234	282	// asmlinkage long sys_listen(int, int);
	283	pub const listen = @compileError("TODO: listen");
235	284
236	285	// getsockname
237	286	// int getsockname(int sockfd, struct sockaddr restrict addr, socklen_t restrict addrlen);
238	287	// asmlinkage long sys_getsockname(int, struct sockaddr __user , int __user );
	288	pub const getsockname = @compileError("TODO: getsockname");
239	289
240	290	// getpeername
241	291	// int getpeername(int sockfd, struct sockaddr restrict addr, socklen_t restrict addrlen);
242	292	// asmlinkage long sys_getpeername(int, struct sockaddr __user , int __user );
	293	pub const getpeername = @compileError("TODO: getpeername");
243	294
244	295	// socketpair
245	296	// int socketpair(int domain, int type, int protocol, int sv[2]);
246	297	// asmlinkage long sys_socketpair(int, int, int, int __user *);
	298	pub const socketpair = @compileError("TODO: socketpair");
247	299
248	300	// setsockopt
249	301	// int setsockopt(int sockfd, int level, int optname, const void optval[.optlen], socklen_t optlen);
250	302	// asmlinkage long sys_setsockopt(int fd, int level, int optname, char __user *optval, int optlen);
	303	pub const setsockopt = @compileError("TODO: setsockopt");
251	304
252	305	// getsockopt
253	306	// int getsockopt(int sockfd, int level, int optname, void optval[restrict .optlen], socklen_t restrict optlen);
254	307	// asmlinkage long sys_getsockopt(int fd, int level, int optname, char __user optval, int __user optlen);
	308	pub const getsockopt = @compileError("TODO: getsockopt");
255	309
256	310	// clone
257	311	// int clone(int (fn)(void _Nullable), void stack, int flags, void _Nullable arg, ... /* pid_t _Nullable parent_tid, void _Nullable tls, pid_t _Nullable child_tid / );
258	312	// asmlinkage long sys_clone(unsigned long, unsigned long, int __user , int __user , unsigned long);
	313	pub const clone = @compileError("TODO: clone");
259	314
260	315	// fork
261	316	// pid_t fork(void);
262	317	// asmlinkage long sys_fork(void);
	318	pub const fork = @compileError("TODO: fork");
263	319
264	320	// vfork
265	321	// pid_t vfork(void);
266	322	// asmlinkage long sys_vfork(void);
	323	pub const vfork = @compileError("TODO: vfork");
267	324
268	325	// execve
269	326	// int execve(const char pathname, char const _Nullable argv[], char *const _Nullable envp[]);
270	327	// asmlinkage long sys_execve(const char __user filename, const char __user const __user argv, const char __user const __user *envp);
	328	pub const execve = @compileError("TODO: execve");
271	329
272	330	// exit
273	331	// [[noreturn]] void _exit(int status);
274	332	// asmlinkage long sys_exit(int error_code);
	333	pub const exit = @compileError("TODO: exit");
275	334
276	335	// wait4
277	336	// pid_t wait4(pid_t pid, int _Nullable wstatus, int options, struct rusage _Nullable rusage);
278	337	// asmlinkage long sys_wait4(pid_t pid, int __user stat_addr, int options, struct rusage __user ru);
	338	pub const wait4 = @compileError("TODO: wait4");
279	339
280	340	// kill
281	341	// int kill(pid_t pid, int sig);
282	342	// asmlinkage long sys_kill(pid_t pid, int sig);
	343	pub const kill = @compileError("TODO: kill");
283	344
284	345	// uname
285	346	// int uname(struct utsname *buf);
286	347	// asmlinkage long sys_uname(struct old_utsname __user *);
	348	pub const uname = @compileError("TODO: uname");
287	349
288	350	// semget
289	351	// int semget(key_t key, int nsems, int semflg);
290	352	// asmlinkage long sys_semget(key_t key, int nsems, int semflg);
	353	pub const semget = @compileError("TODO: semget");
291	354
292	355	// semop
293	356	// int semop(int semid, struct sembuf *sops, size_t nsops);
294	357	// asmlinkage long sys_semop(int semid, struct sembuf __user *sops, unsigned nsops);
	358	pub const semop = @compileError("TODO: semop");
295	359
296	360	// semctl
297	361	// int semctl(int semid, int semnum, int op, ...);
298	362	// asmlinkage long sys_semctl(int semid, int semnum, int cmd, unsigned long arg);
	363	pub const semctl = @compileError("TODO: semctl");
299	364
300	365	// shmdt
301	366	// int shmdt(const void *shmaddr);
302	367	// asmlinkage long sys_shmdt(char __user *shmaddr);
	368	pub const shmdt = @compileError("TODO: shmdt");
303	369
304	370	// msgget
305	371	// int msgget(key_t key, int msgflg);
306	372	// asmlinkage long sys_msgget(key_t key, int msgflg);
	373	pub const msgget = @compileError("TODO: msgget");
307	374
308	375	// msgsnd
309	376	// int msgsnd(int msqid, const void msgp[.msgsz], size_t msgsz, int msgflg);
310	377	// asmlinkage long sys_msgsnd(int msqid, struct msgbuf __user *msgp, size_t msgsz, int msgflg);
	378	pub const msgsnd = @compileError("TODO: msgsnd");
311	379
312	380	// msgrcv
313	381	// ssize_t msgrcv(int msqid, void msgp[.msgsz], size_t msgsz, long msgtyp, int msgflg);
314	382	// asmlinkage long sys_msgrcv(int msqid, struct msgbuf __user *msgp, size_t msgsz, long msgtyp, int msgflg);
	383	pub const msgrcv = @compileError("TODO: msgrcv");
315	384
316	385	// msgctl
317	386	// int msgctl(int msqid, int op, struct msqid_ds *buf);
318	387	// asmlinkage long sys_msgctl(int msqid, int cmd, struct msqid_ds __user *buf);
	388	pub const msgctl = @compileError("TODO: msgctl");
319	389
320	390	// fcntl
321	391	// int fcntl(int fd, int op, ... /* arg */ );
322	392	// asmlinkage long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg);
	393	pub const fcntl = @compileError("TODO: fcntl");
323	394
324	395	// flock
325	396	// int flock(int fd, int op);
326	397	// asmlinkage long sys_flock(unsigned int fd, unsigned int cmd);
	398	pub const flock = @compileError("TODO: flock");
327	399
328	400	// fsync
329	401	// int fsync(int fd);
330	402	// asmlinkage long sys_fsync(unsigned int fd);
	403	pub const fsync = @compileError("TODO: fsync");
331	404
332	405	// fdatasync
333	406	// int fdatasync(int fd);
334	407	// asmlinkage long sys_fdatasync(unsigned int fd);
	408	pub const fdatasync = @compileError("TODO: fdatasync");
335	409
336	410	// truncate
337	411	// int truncate(const char *path, off_t length);
338	412	// asmlinkage long sys_truncate(const char __user *path, long length);
	413	pub const truncate = @compileError("TODO: truncate");
339	414
340	415	// ftruncate
341	416	// int ftruncate(int fd, off_t length);
342	417	// asmlinkage long sys_ftruncate(unsigned int fd, off_t length);
	418	pub const ftruncate = @compileError("TODO: ftruncate");
343	419
344	420	// getdents
345	421	// long syscall(SYS_getdents, unsigned int fd, struct linux_dirent *dirp, unsigned int count);
346	422	// asmlinkage long sys_getdents(unsigned int fd, struct linux_dirent __user *dirent, unsigned int count);
	423	pub const getdents = @compileError("TODO: getdents");
347	424
348	425	// getcwd
349	426	// char *getcwd(char buf[.size], size_t size);
350	427	// asmlinkage long sys_getcwd(char __user *buf, unsigned long size);
	428	pub const getcwd = @compileError("TODO: getcwd");
351	429
352	430	// chdir
353	431	// int chdir(const char *path);
354	432	// asmlinkage long sys_chdir(const char __user *filename);
	433	pub const chdir = @compileError("TODO: chdir");
355	434
356	435	// fchdir
357	436	// int fchdir(int fd);
358	437	// asmlinkage long sys_fchdir(unsigned int fd);
	438	pub const fchdir = @compileError("TODO: fchdir");
359	439
360	440	// rename
361	441	// int rename(const char oldpath, const char newpath);
362	442	// asmlinkage long sys_rename(const char __user oldname, const char __user newname);
	443	pub const rename = @compileError("TODO: rename");
363	444
364	445	// mkdir
365	446	// int mkdir(const char *pathname, mode_t mode);
366	447	// asmlinkage long sys_mkdir(const char __user *pathname, umode_t mode);
	448	pub const mkdir = @compileError("TODO: mkdir");
367	449
368	450	// rmdir
369	451	// int rmdir(const char *pathname);
370	452	// asmlinkage long sys_rmdir(const char __user *pathname);
	453	pub const rmdir = @compileError("TODO: rmdir");
371	454
372	455	// creat
373	456	// int creat(const char *pathname, mode_t mode);
374	457	// asmlinkage long sys_creat(const char __user *pathname, umode_t mode);
	458	pub const creat = @compileError("TODO: creat");
375	459
376	460	// link
377	461	// int link(const char oldpath, const char newpath);
378	462	// asmlinkage long sys_link(const char __user oldname, const char __user newname);
	463	pub const link = @compileError("TODO: link");
379	464
380	465	// unlink
381	466	// int unlink(const char *pathname);
382	467	// asmlinkage long sys_unlink(const char __user *pathname);
	468	pub const unlink = @compileError("TODO: unlink");
383	469
384	470	// symlink
385	471	// int symlink(const char target, const char linkpath);
386	472	// asmlinkage long sys_symlink(const char __user old, const char __user new);
	473	pub const symlink = @compileError("TODO: symlink");
387	474
388	475	// readlink
389	476	// ssize_t readlink(const char restrict pathname, char restrict buf, size_t bufsiz);
390	477	// asmlinkage long sys_readlink(const char __user path, char __user buf, int bufsiz);
	478	pub const readlink = @compileError("TODO: readlink");
391	479
392	480	// chmod
393	481	// int chmod(const char *pathname, mode_t mode);
394	482	// asmlinkage long sys_chmod(const char __user *filename, umode_t mode);
	483	pub const chmod = @compileError("TODO: chmod");
395	484
396	485	// fchmod
397	486	// int fchmod(int fd, mode_t mode);
398	487	// asmlinkage long sys_fchmod(unsigned int fd, umode_t mode);
	488	pub const fchmod = @compileError("TODO: fchmod");
399	489
400	490	// chown
401	491	// int chown(const char *pathname, uid_t owner, gid_t group);
402	492	// asmlinkage long sys_chown(const char __user *filename, uid_t user, gid_t group);
	493	pub const chown = @compileError("TODO: chown");
403	494
404	495	// fchown
405	496	// int fchown(int fd, uid_t owner, gid_t group);
406	497	// asmlinkage long sys_fchown(unsigned int fd, uid_t user, gid_t group);
	498	pub const fchown = @compileError("TODO: fchown");
407	499
408	500	// lchown
409	501	// int lchown(const char *pathname, uid_t owner, gid_t group);
410	502	// asmlinkage long sys_lchown(const char __user *filename, uid_t user, gid_t group);
	503	pub const lchown = @compileError("TODO: lchown");
411	504
412	505	// umask
413	506	// mode_t umask(mode_t mask);
414	507	// asmlinkage long sys_umask(int mask);
	508	pub const umask = @compileError("TODO: umask");
415	509
416	510	// gettimeofday
417	511	// int gettimeofday(struct timeval restrict tv, struct timezone _Nullable restrict tz);
418	512	// asmlinkage long sys_gettimeofday(struct __kernel_old_timeval __user tv, struct timezone __user tz);
	513	pub const gettimeofday = @compileError("TODO: gettimeofday");
419	514
420	515	// getrlimit
421	516	// int getrlimit(int resource, struct rlimit *rlim);
422	517	// asmlinkage long sys_getrlimit(unsigned int resource, struct rlimit __user *rlim);
	518	pub const getrlimit = @compileError("TODO: getrlimit");
423	519
424	520	// getrusage
425	521	// int getrusage(int who, struct rusage *usage);
426	522	// asmlinkage long sys_getrusage(int who, struct rusage __user *ru);
	523	pub const getrusage = @compileError("TODO: getrusage");
427	524
428	525	// sysinfo
429	526	// int sysinfo(struct sysinfo *info);
430	527	// asmlinkage long sys_sysinfo(struct sysinfo __user *info);
	528	pub const sysinfo = @compileError("TODO: sysinfo");
431	529
432	530	// times
433	531	// clock_t times(struct tms *buf);
434	532	// asmlinkage long sys_times(struct tms __user *tbuf);
	533	pub const times = @compileError("TODO: times");
435	534
436	535	// ptrace
437	536	// long ptrace(enum __ptrace_request op, pid_t pid, void addr, void data);
438	537	// asmlinkage long sys_ptrace(long request, long pid, unsigned long addr, unsigned long data);
	538	pub const ptrace = @compileError("TODO: ptrace");
439	539
440	540	// getuid
441	541	// uid_t getuid(void);
442	542	// asmlinkage long sys_getuid(void);
	543	pub const getuid = @compileError("TODO: getuid");
443	544
444	545	// syslog
445	546	// int syscall(SYS_syslog, int type, char *bufp, int len);
446	547	// asmlinkage long sys_syslog(int type, char __user *buf, int len);
	548	pub const syslog = @compileError("TODO: syslog");
447	549
448	550	// getgid
449	551	// gid_t getgid(void);
450	552	// asmlinkage long sys_getgid(void);
	553	pub const getgid = @compileError("TODO: getgid");
451	554
452	555	// setuid
453	556	// int setuid(uid_t uid);
454	557	// asmlinkage long sys_setuid(uid_t uid);
	558	pub const setuid = @compileError("TODO: setuid");
455	559
456	560	// setgid
457	561	// int setgid(gid_t gid);
458	562	// asmlinkage long sys_setgid(gid_t gid);
	563	pub const setgid = @compileError("TODO: setgid");
459	564
460	565	// geteuid
461	566	// uid_t geteuid(void);
462	567	// asmlinkage long sys_geteuid(void);
	568	pub const geteuid = @compileError("TODO: geteuid");
463	569
464	570	// getegid
465	571	// gid_t getegid(void);
466	572	// asmlinkage long sys_getegid(void);
	573	pub const getegid = @compileError("TODO: getegid");
467	574
468	575	// setpgid
469	576	// int setpgid(pid_t pid, pid_t pgid);
470	577	// asmlinkage long sys_setpgid(pid_t pid, pid_t pgid);
	578	pub const setpgid = @compileError("TODO: setpgid");
471	579
472	580	// getppid
473	581	// pid_t getppid(void);
474	582	// asmlinkage long sys_getppid(void);
	583	pub const getppid = @compileError("TODO: getppid");
475	584
476	585	// getpgrp
477	586	// pid_t getpgrp(void);
478	587	// asmlinkage long sys_getpgrp(void);
	588	pub const getpgrp = @compileError("TODO: getpgrp");
479	589
480	590	// setsid
481	591	// pid_t setsid(void);
482	592	// asmlinkage long sys_setsid(void);
	593	pub const setsid = @compileError("TODO: setsid");
483	594
484	595	// setreuid
485	596	// int setreuid(uid_t ruid, uid_t euid);
486	597	// asmlinkage long sys_setreuid(uid_t ruid, uid_t euid);
	598	pub const setreuid = @compileError("TODO: setreuid");
487	599
488	600	// setregid
489	601	// int setregid(gid_t rgid, gid_t egid);
490	602	// asmlinkage long sys_setregid(gid_t rgid, gid_t egid);
	603	pub const setregid = @compileError("TODO: setregid");
491	604
492	605	// getgroups
493	606	// int getgroups(int size, gid_t list[]);
494	607	// asmlinkage long sys_getgroups(int gidsetsize, gid_t __user *grouplist);
	608	pub const getgroups = @compileError("TODO: getgroups");
495	609
496	610	// setgroups
497	611	// int setgroups(size_t size, const gid_t *_Nullable list);
498	612	// asmlinkage long sys_setgroups(int gidsetsize, gid_t __user *grouplist);
	613	pub const setgroups = @compileError("TODO: setgroups");
499	614
500	615	// setresuid
501	616	// int setresuid(uid_t ruid, uid_t euid, uid_t suid);
502	617	// asmlinkage long sys_setresuid(uid_t ruid, uid_t euid, uid_t suid);
	618	pub const setresuid = @compileError("TODO: setresuid");
503	619
504	620	// getresuid
505	621	// int getresuid(uid_t ruid, uid_t euid, uid_t *suid);
506	622	// asmlinkage long sys_getresuid(uid_t __user ruid, uid_t __user euid, uid_t __user *suid);
	623	pub const getresuid = @compileError("TODO: getresuid");
507	624
508	625	// setresgid
509	626	// int setresgid(gid_t rgid, gid_t egid, gid_t sgid);
510	627	// asmlinkage long sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid);
	628	pub const setresgid = @compileError("TODO: setresgid");
511	629
512	630	// getresgid
513	631	// int getresgid(gid_t rgid, gid_t egid, gid_t *sgid);
514	632	// asmlinkage long sys_getresgid(gid_t __user rgid, gid_t __user egid, gid_t __user *sgid);
	633	pub const getresgid = @compileError("TODO: getresgid");
515	634
516	635	// getpgid
517	636	// pid_t getpgid(pid_t pid);
518	637	// asmlinkage long sys_getpgid(pid_t pid);
	638	pub const getpgid = @compileError("TODO: getpgid");
519	639
520	640	// setfsuid
521	641	// [[deprecated]] int setfsuid(uid_t fsuid);
522	642	// asmlinkage long sys_setfsuid(uid_t uid);
	643	pub const setfsuid = @compileError("TODO: setfsuid");
523	644
524	645	// setfsgid
525	646	// [[deprecated]] int setfsgid(gid_t fsgid);
526	647	// asmlinkage long sys_setfsgid(gid_t gid);
	648	pub const setfsgid = @compileError("TODO: setfsgid");
527	649
528	650	// getsid
529	651	// pid_t getsid(pid_t pid);
530	652	// asmlinkage long sys_getsid(pid_t pid);
	653	pub const getsid = @compileError("TODO: getsid");
531	654
532	655	// capget
533	656	// int syscall(SYS_capget, cap_user_header_t hdrp, cap_user_data_t datap);
534	657	// asmlinkage long sys_capget(cap_user_header_t header, cap_user_data_t dataptr);
	658	pub const capget = @compileError("TODO: capget");
535	659
536	660	// capset
537	661	// int syscall(SYS_capset, cap_user_header_t hdrp, const cap_user_data_t datap);
538	662	// asmlinkage long sys_capset(cap_user_header_t header, const cap_user_data_t data);
	663	pub const capset = @compileError("TODO: capset");
539	664
540	665	// rt_sigpending
541	666	// int sigpending(sigset_t *set);
542	667	// asmlinkage long sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize);
	668	pub const rt_sigpending = @compileError("TODO: rt_sigpending");
543	669
544	670	// rt_sigtimedwait
545	671	// int sigtimedwait(const sigset_t restrict set, siginfo_t _Nullable restrict info, const struct timespec *restrict timeout);
546	672	// asmlinkage long sys_rt_sigtimedwait(const sigset_t __user uthese, siginfo_t __user uinfo, const struct __kernel_timespec __user *uts, size_t sigsetsize);
	673	pub const rt_sigtimedwait = @compileError("TODO: rt_sigtimedwait");
547	674
548	675	// rt_sigqueueinfo
549	676	// int syscall(SYS_rt_sigqueueinfo, pid_t tgid, int sig, siginfo_t *info);
550	677	// asmlinkage long sys_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t __user *uinfo);
	678	pub const rt_sigqueueinfo = @compileError("TODO: rt_sigqueueinfo");
551	679
552	680	// rt_sigsuspend
553	681	// int sigsuspend(const sigset_t *mask);
554	682	// asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize);
	683	pub const rt_sigsuspend = @compileError("TODO: rt_sigsuspend");
555	684
556	685	// sigaltstack
557	686	// int sigaltstack(const stack_t _Nullable restrict ss, stack_t _Nullable restrict old_ss);
558	687	// asmlinkage long sys_sigaltstack(const struct sigaltstack __user uss, struct sigaltstack __user uoss);
	688	pub const sigaltstack = @compileError("TODO: sigaltstack");
559	689
560	690	// utime
561	691	// int utime(const char filename, const struct utimbuf _Nullable times);
562	692	// asmlinkage long sys_utime(char __user filename, struct utimbuf __user times);
	693	pub const utime = @compileError("TODO: utime");
563	694
564	695	// mknod
565	696	// int mknod(const char *pathname, mode_t mode, dev_t dev);
566	697	// asmlinkage long sys_mknod(const char __user *filename, umode_t mode, unsigned dev);
	698	pub const mknod = @compileError("TODO: mknod");
567	699
568	700	// uselib
569	701	// [[deprecated]] int uselib(const char *library);
570	702	// asmlinkage long sys_uselib(const char __user *library);
	703	pub const uselib = @compileError("TODO: uselib");
571	704
572	705	// personality
573	706	// int personality(unsigned long persona);
574	707	// asmlinkage long sys_personality(unsigned int personality);
	708	pub const personality = @compileError("TODO: personality");
575	709
576	710	// ustat
577	711	// [[deprecated]] int ustat(dev_t dev, struct ustat *ubuf);
578	712	// asmlinkage long sys_ustat(unsigned dev, struct ustat __user *ubuf);
	713	pub const ustat = @compileError("TODO: ustat");
579	714
580	715	// statfs
581	716	// int statfs(const char path, struct statfs buf);
582	717	// asmlinkage long sys_statfs(const char __user * path, struct statfs __user *buf);
	718	pub const statfs = @compileError("TODO: statfs");
583	719
584	720	// fstatfs
585	721	// int fstatfs(int fd, struct statfs *buf);
586	722	// asmlinkage long sys_fstatfs(unsigned int fd, struct statfs __user *buf);
	723	pub const fstatfs = @compileError("TODO: fstatfs");
587	724
588	725	// sysfs
589	726	//
590	727	// asmlinkage long sys_sysfs(int option, unsigned long arg1, unsigned long arg2);
	728	pub const sysfs = @compileError("TODO: sysfs");
591	729
592	730	// getpriority
593	731	// int getpriority(int which, id_t who);
594	732	// asmlinkage long sys_getpriority(int which, int who);
	733	pub const getpriority = @compileError("TODO: getpriority");
595	734
596	735	// setpriority
597	736	// int setpriority(int which, id_t who, int prio);
598	737	// asmlinkage long sys_setpriority(int which, int who, int niceval);
	738	pub const setpriority = @compileError("TODO: setpriority");
599	739
600	740	// sched_setparam
601	741	// int sched_setparam(pid_t pid, const struct sched_param *param);
602	742	// asmlinkage long sys_sched_setparam(pid_t pid, struct sched_param __user *param);
	743	pub const sched_setparam = @compileError("TODO: sched_setparam");
603	744
604	745	// sched_getparam
605	746	// int sched_getparam(pid_t pid, struct sched_param *param);
606	747	// asmlinkage long sys_sched_getparam(pid_t pid, struct sched_param __user *param);
	748	pub const sched_getparam = @compileError("TODO: sched_getparam");
607	749
608	750	// sched_setscheduler
609	751	// int sched_setscheduler(pid_t pid, int policy, const struct sched_param *param);
610	752	// asmlinkage long sys_sched_setscheduler(pid_t pid, int policy, struct sched_param __user *param);
	753	pub const sched_setscheduler = @compileError("TODO: sched_setscheduler");
611	754
612	755	// sched_getscheduler
613	756	// int sched_getscheduler(pid_t pid);
614	757	// asmlinkage long sys_sched_getscheduler(pid_t pid);
	758	pub const sched_getscheduler = @compileError("TODO: sched_getscheduler");
615	759
616	760	// sched_get_priority_max
617	761	// int sched_get_priority_max(int policy);
618	762	// asmlinkage long sys_sched_get_priority_max(int policy);
	763	pub const sched_get_priority_max = @compileError("TODO: sched_get_priority_max");
619	764
620	765	// sched_get_priority_min
621	766	// int sched_get_priority_min(int policy);
622	767	// asmlinkage long sys_sched_get_priority_min(int policy);
	768	pub const sched_get_priority_min = @compileError("TODO: sched_get_priority_min");
623	769
624	770	// sched_rr_get_interval
625	771	// int sched_rr_get_interval(pid_t pid, struct timespec *tp);
626	772	// asmlinkage long sys_sched_rr_get_interval(pid_t pid, struct __kernel_timespec __user *interval);
	773	pub const sched_rr_get_interval = @compileError("TODO: sched_rr_get_interval");
627	774
628	775	// mlock
629	776	// int mlock(const void addr[.len], size_t len);
630	777	// asmlinkage long sys_mlock(unsigned long start, size_t len);
	778	pub const mlock = @compileError("TODO: mlock");
631	779
632	780	// munlock
633	781	// int munlock(const void addr[.len], size_t len);
634	782	// asmlinkage long sys_munlock(unsigned long start, size_t len);
	783	pub const munlock = @compileError("TODO: munlock");
635	784
636	785	// mlockall
637	786	// int mlockall(int flags);
638	787	// asmlinkage long sys_mlockall(int flags);
	788	pub const mlockall = @compileError("TODO: mlockall");
639	789
640	790	// munlockall
641	791	// int munlockall(void);
642	792	// asmlinkage long sys_munlockall(void);
	793	pub const munlockall = @compileError("TODO: munlockall");
643	794
644	795	// vhangup
645	796	// int vhangup(void);
646	797	// asmlinkage long sys_vhangup(void);
	798	pub const vhangup = @compileError("TODO: vhangup");
647	799
648	800	// pivot_root
649	801	// int syscall(SYS_pivot_root, const char new_root, const char put_old);
650	802	// asmlinkage long sys_pivot_root(const char __user new_root, const char __user put_old);
	803	pub const pivot_root = @compileError("TODO: pivot_root");
651	804
652	805	// prctl
653	806	// int prctl(int op, ... /* unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5 */ );
654	807	// asmlinkage long sys_prctl(int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5);
	808	pub const prctl = @compileError("TODO: prctl");
655	809
656	810	// arch_prctl
657	811	//
658	812	// asmlinkage long sys_arch_prctl(int option, unsigned long arg2)
	813	pub const arch_prctl = @compileError("TODO: arch_prctl");
659	814
660	815	// adjtimex
661	816	// int adjtimex(struct timex *buf);
662	817	// asmlinkage long sys_adjtimex(struct __kernel_timex __user *txc_p);
	818	pub const adjtimex = @compileError("TODO: adjtimex");
663	819
664	820	// setrlimit
665	821	// int setrlimit(int resource, const struct rlimit *rlim);
666	822	// asmlinkage long sys_setrlimit(unsigned int resource, struct rlimit __user *rlim);
	823	pub const setrlimit = @compileError("TODO: setrlimit");
667	824
668	825	// chroot
669	826	// int chroot(const char *path);
670	827	// asmlinkage long sys_chroot(const char __user *filename);
	828	pub const chroot = @compileError("TODO: chroot");
671	829
672	830	// sync
673	831	// void sync(void);
674	832	// asmlinkage long sys_sync(void);
	833	pub const sync = @compileError("TODO: sync");
675	834
676	835	// acct
677	836	// int acct(const char *_Nullable filename);
678	837	// asmlinkage long sys_acct(const char __user *name);
	838	pub const acct = @compileError("TODO: acct");
679	839
680	840	// settimeofday
681	841	// int settimeofday(const struct timeval tv, const struct timezone _Nullable tz);
682	842	// asmlinkage long sys_settimeofday(struct __kernel_old_timeval __user tv, struct timezone __user tz);
	843	pub const settimeofday = @compileError("TODO: settimeofday");
683	844
684	845	// mount
685	846	// int mount(const char source, const char target, const char filesystemtype, unsigned long mountflags, const void _Nullable data);
686	847	// asmlinkage long sys_mount(char __user dev_name, char __user dir_name, char __user type, unsigned long flags, void __user data);
	848	pub const mount = @compileError("TODO: mount");
687	849
688	850	// umount2
689	851	// int umount2(const char *target, int flags);
690	852	// asmlinkage long sys_umount(char __user *name, int flags);
	853	pub const umount = @compileError("TODO: umount");
691	854
692	855	// swapon
693	856	// int swapon(const char *path, int swapflags);
694	857	// asmlinkage long sys_swapon(const char __user *specialfile, int swap_flags);
	858	pub const swapon = @compileError("TODO: swapon");
695	859
696	860	// swapoff
697	861	// int swapoff(const char *path);
698	862	// asmlinkage long sys_swapoff(const char __user *specialfile);
	863	pub const swapoff = @compileError("TODO: swapoff");
699	864
700	865	// reboot
701	866	// int reboot(int op);
702	867	// asmlinkage long sys_reboot(int magic1, int magic2, unsigned int cmd, void __user *arg);
	868	pub const reboot = @compileError("TODO: reboot");
703	869
704	870	// sethostname
705	871	// int sethostname(const char *name, size_t len);
706	872	// asmlinkage long sys_sethostname(char __user *name, int len);
	873	pub const sethostname = @compileError("TODO: sethostname");
707	874
708	875	// setdomainname
709	876	// int setdomainname(const char *name, size_t len);
710	877	// asmlinkage long sys_setdomainname(char __user *name, int len);
	878	pub const setdomainname = @compileError("TODO: setdomainname");
711	879
712	880	// ioperm
713	881	// int ioperm(unsigned long from, unsigned long num, int turn_on);
714	882	// asmlinkage long sys_ioperm(unsigned long from, unsigned long num, int on);
	883	pub const ioperm = @compileError("TODO: ioperm");
715	884
716	885	// init_module
717	886	// int syscall(SYS_init_module, void module_image[.len], unsigned long len, const char *param_values);
718	887	// asmlinkage long sys_init_module(void __user umod, unsigned long len, const char __user uargs);
	888	pub const init_module = @compileError("TODO: init_module");
719	889
720	890	// delete_module
721	891	// int syscall(SYS_delete_module, const char *name, unsigned int flags);
722	892	// asmlinkage long sys_delete_module(const char __user *name_user, unsigned int flags);
	893	pub const delete_module = @compileError("TODO: delete_module");
723	894
724	895	// quotactl
725	896	// int quotactl(int op, const char *_Nullable special, int id, caddr_t addr);
726	897	// asmlinkage long sys_quotactl(unsigned int cmd, const char __user special, qid_t id, void __user addr);
	898	pub const quotactl = @compileError("TODO: quotactl");
727	899
728	900	// gettid
729	901	// pid_t gettid(void);
730	902	// asmlinkage long sys_gettid(void);
	903	pub const gettid = @compileError("TODO: gettid");
731	904
732	905	// readahead
733	906	// ssize_t readahead(int fd, off_t offset, size_t count);
734	907	// asmlinkage long sys_readahead(int fd, loff_t offset, size_t count);
	908	pub const readahead = @compileError("TODO: readahead");
735	909
736	910	// setxattr
737	911	// int setxattr(const char path, const char name, const void value[.size], size_t size, int flags);
738	912	// asmlinkage long sys_setxattr(const char __user path, const char __user name, const void __user *value, size_t size, int flags);
	913	pub const setxattr = @compileError("TODO: setxattr");
739	914
740	915	// lsetxattr
741	916	// int lsetxattr(const char path, const char name, const void value[.size], size_t size, int flags);
742	917	// asmlinkage long sys_lsetxattr(const char __user path, const char __user name, const void __user *value, size_t size, int flags);
	918	pub const lsetxattr = @compileError("TODO: lsetxattr");
743	919
744	920	// fsetxattr
745	921	// int fsetxattr(int fd, const char *name, const void value[.size], size_t size, int flags);
746	922	// asmlinkage long sys_fsetxattr(int fd, const char __user name, const void __user value, size_t size, int flags);
	923	pub const fsetxattr = @compileError("TODO: fsetxattr");
747	924
748	925	// getxattr
749	926	// ssize_t getxattr(const char path, const char name, void value[.size], size_t size);
750	927	// asmlinkage long sys_getxattr(const char __user path, const char __user name, void __user *value, size_t size);
	928	pub const getxattr = @compileError("TODO: getxattr");
751	929
752	930	// lgetxattr
753	931	// ssize_t lgetxattr(const char path, const char name, void value[.size], size_t size);
754	932	// asmlinkage long sys_lgetxattr(const char __user path, const char __user name, void __user *value, size_t size);
	933	pub const lgetxattr = @compileError("TODO: lgetxattr");
755	934
756	935	// fgetxattr
757	936	// ssize_t fgetxattr(int fd, const char *name, void value[.size], size_t size);
758	937	// asmlinkage long sys_fgetxattr(int fd, const char __user name, void __user value, size_t size);
	938	pub const fgetxattr = @compileError("TODO: fgetxattr");
759	939
760	940	// listxattr
761	941	// ssize_t listxattr(const char path, char _Nullable list, size_t size);
762	942	// asmlinkage long sys_listxattr(const char __user path, char __user list, size_t size);
	943	pub const listxattr = @compileError("TODO: listxattr");
763	944
764	945	// llistxattr
765	946	// ssize_t llistxattr(const char path, char _Nullable list, size_t size);
766	947	// asmlinkage long sys_llistxattr(const char __user path, char __user list, size_t size);
	948	pub const llistxattr = @compileError("TODO: llistxattr");
767	949
768	950	// flistxattr
769	951	// ssize_t flistxattr(int fd, char *_Nullable list, size_t size);
770	952	// asmlinkage long sys_flistxattr(int fd, char __user *list, size_t size);
	953	pub const flistxattr = @compileError("TODO: flistxattr");
771	954
772	955	// removexattr
773	956	// int removexattr(const char path, const char name);
774	957	// asmlinkage long sys_removexattr(const char __user path, const char __user name);
	958	pub const removexattr = @compileError("TODO: removexattr");
775	959
776	960	// lremovexattr
777	961	// int lremovexattr(const char path, const char name);
778	962	// asmlinkage long sys_lremovexattr(const char __user path, const char __user name);
	963	pub const lremovexattr = @compileError("TODO: lremovexattr");
779	964
780	965	// fremovexattr
781	966	// int fremovexattr(int fd, const char *name);
782	967	// asmlinkage long sys_fremovexattr(int fd, const char __user *name);
	968	pub const fremovexattr = @compileError("TODO: fremovexattr");
783	969
784	970	// tkill
785	971	// [[deprecated]] int syscall(SYS_tkill, pid_t tid, int sig);
786	972	// asmlinkage long sys_tkill(pid_t pid, int sig);
	973	pub const tkill = @compileError("TODO: tkill");
787	974
788	975	// time
789	976	// time_t time(time_t *_Nullable tloc);
790	977	// asmlinkage long sys_time(__kernel_old_time_t __user *tloc);
	978	pub const time = @compileError("TODO: time");
791	979
792	980	// futex
793	981	// long syscall(SYS_futex, uint32_t uaddr, int futex_op, uint32_t val, const struct timespec timeout, /* or: uint32_t val2 / uint32_t uaddr2, uint32_t val3);
794	982	// asmlinkage long sys_futex(u32 __user uaddr, int op, u32 val, const struct __kernel_timespec __user utime, u32 __user *uaddr2, u32 val3);
	983	pub const futex = @compileError("TODO: futex");
795	984
796	985	// sched_setaffinity
797	986	// int sched_setaffinity(pid_t pid, size_t cpusetsize, const cpu_set_t *mask);
798	987	// asmlinkage long sys_sched_setaffinity(pid_t pid, unsigned int len, unsigned long __user *user_mask_ptr);
	988	pub const sched_setaffinity = @compileError("TODO: sched_setaffinity");
799	989
800	990	// sched_getaffinity
801	991	// int sched_getaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask);
802	992	// asmlinkage long sys_sched_getaffinity(pid_t pid, unsigned int len, unsigned long __user *user_mask_ptr);
	993	pub const sched_getaffinity = @compileError("TODO: sched_getaffinity");
803	994
804	995	// io_setup
805	996	// long io_setup(unsigned int nr_events, aio_context_t *ctx_idp);
806	997	// asmlinkage long sys_io_setup(unsigned nr_reqs, aio_context_t __user *ctx);
	998	pub const io_setup = @compileError("TODO: io_setup");
807	999
808	1000	// io_destroy
809	1001	// int syscall(SYS_io_destroy, aio_context_t ctx_id);
810	1002	// asmlinkage long sys_io_destroy(aio_context_t ctx);
	1003	pub const io_destroy = @compileError("TODO: io_destroy");
811	1004
812	1005	// io_getevents
813	1006	// int syscall(SYS_io_getevents, aio_context_t ctx_id, long min_nr, long nr, struct io_event events, struct timespec timeout);
814	1007	// asmlinkage long sys_io_getevents(aio_context_t ctx_id, long min_nr, long nr, struct io_event __user events, struct __kernel_timespec __user timeout);
	1008	pub const io_getevents = @compileError("TODO: io_getevents");
815	1009
816	1010	// io_submit
817	1011	// int io_submit(aio_context_t ctx_id, long nr, struct iocb **iocbpp);
818	1012	// asmlinkage long sys_io_submit(aio_context_t, long, struct iocb __user * __user *);
	1013	pub const io_submit = @compileError("TODO: io_submit");
819	1014
820	1015	// io_cancel
821	1016	// int syscall(SYS_io_cancel, aio_context_t ctx_id, struct iocb iocb, struct io_event result);
822	1017	// asmlinkage long sys_io_cancel(aio_context_t ctx_id, struct iocb __user iocb, struct io_event __user result);
	1018	pub const io_cancel = @compileError("TODO: io_cancel");
823	1019
824	1020	// epoll_create
825	1021	// int epoll_create(int size);
826	1022	// asmlinkage long sys_epoll_create(int size);
	1023	pub const epoll_create = @compileError("TODO: epoll_create");
827	1024
828	1025	// remap_file_pages
829	1026	// [[deprecated]] int remap_file_pages(void addr[.size], size_t size, int prot, size_t pgoff, int flags);
830	1027	// asmlinkage long sys_remap_file_pages(unsigned long start, unsigned long size, unsigned long prot, unsigned long pgoff, unsigned long flags);
	1028	pub const remap_file_pages = @compileError("TODO: remap_file_pages");
831	1029
832	1030	// getdents64
833	1031	// ssize_t getdents64(int fd, void dirp[.count], size_t count);
834	1032	// asmlinkage long sys_getdents64(unsigned int fd, struct linux_dirent64 __user *dirent, unsigned int count);
	1033	pub const getdents64 = @compileError("TODO: getdents64");
835	1034
836	1035	// set_tid_address
837	1036	// pid_t syscall(SYS_set_tid_address, int *tidptr);
838	1037	// asmlinkage long sys_set_tid_address(int __user *tidptr);
	1038	pub const set_tid_address = @compileError("TODO: set_tid_address");
839	1039
840	1040	// semtimedop
841	1041	// int semtimedop(int semid, struct sembuf sops, size_t nsops, const struct timespec _Nullable timeout);
842	1042	// asmlinkage long sys_semtimedop(int semid, struct sembuf __user sops, unsigned nsops, const struct __kernel_timespec __user timeout);
	1043	pub const semtimedop = @compileError("TODO: semtimedop");
843	1044
844	1045	// fadvise64
845	1046	// int posix_fadvise(int fd, off_t offset, off_t size, int advice);
846	1047	// asmlinkage long sys_fadvise64(int fd, loff_t offset, size_t len, int advice);
	1048	pub const fadvise64 = @compileError("TODO: fadvise64");
847	1049
848	1050	// timer_create
849	1051	// int timer_create(clockid_t clockid, struct sigevent _Nullable restrict sevp, timer_t restrict timerid);
850	1052	// asmlinkage long sys_timer_create(clockid_t which_clock, struct sigevent __user timer_event_spec, timer_t __user created_timer_id);
	1053	pub const timer_create = @compileError("TODO: timer_create");
851	1054
852	1055	// timer_settime
853	1056	// int timer_settime(timer_t timerid, int flags, const struct itimerspec restrict new_value, struct itimerspec _Nullable restrict old_value);
854	1057	// asmlinkage long sys_timer_settime(timer_t timer_id, int flags, const struct __kernel_itimerspec __user new_setting, struct __kernel_itimerspec __user old_setting);
	1058	pub const timer_settime = @compileError("TODO: timer_settime");
855	1059
856	1060	// timer_gettime
857	1061	// int timer_gettime(timer_t timerid, struct itimerspec *curr_value);
858	1062	// asmlinkage long sys_timer_gettime(timer_t timer_id, struct __kernel_itimerspec __user *setting);
	1063	pub const timer_gettime = @compileError("TODO: timer_gettime");
859	1064
860	1065	// timer_getoverrun
861	1066	// int timer_getoverrun(timer_t timerid);
862	1067	// asmlinkage long sys_timer_getoverrun(timer_t timer_id);
	1068	pub const timer_getoverrun = @compileError("TODO: timer_getoverrun");
863	1069
864	1070	// timer_delete
865	1071	// int timer_delete(timer_t timerid);
866	1072	// asmlinkage long sys_timer_delete(timer_t timer_id);
	1073	pub const timer_delete = @compileError("TODO: timer_delete");
867	1074
868	1075	// clock_settime
869	1076	// int clock_settime(clockid_t clockid, const struct timespec *tp);
870	1077	// asmlinkage long sys_clock_settime(clockid_t which_clock, const struct __kernel_timespec __user *tp);
	1078	pub const clock_settime = @compileError("TODO: clock_settime");
871	1079
872	1080	// clock_gettime
873	1081	// int clock_gettime(clockid_t clockid, struct timespec *tp);
874	1082	// asmlinkage long sys_clock_gettime(clockid_t which_clock, struct __kernel_timespec __user *tp);
	1083	pub const clock_gettime = @compileError("TODO: clock_gettime");
875	1084
876	1085	// clock_getres
877	1086	// int clock_getres(clockid_t clockid, struct timespec *_Nullable res);
878	1087	// asmlinkage long sys_clock_getres(clockid_t which_clock, struct __kernel_timespec __user *tp);
	1088	pub const clock_getres = @compileError("TODO: clock_getres");
879	1089
880	1090	// clock_nanosleep
881	1091	// int clock_nanosleep(clockid_t clockid, int flags, const struct timespec t, struct timespec _Nullable remain);
882	1092	// asmlinkage long sys_clock_nanosleep(clockid_t which_clock, int flags, const struct __kernel_timespec __user rqtp, struct __kernel_timespec __user rmtp);
	1093	pub const clock_nanosleep = @compileError("TODO: clock_nanosleep");
883	1094
884	1095	// exit_group
885	1096	// [[noreturn]] void syscall(SYS_exit_group, int status);
886	1097	// asmlinkage long sys_exit_group(int error_code);
	1098	pub const exit_group = @compileError("TODO: exit_group");
887	1099
888	1100	// epoll_wait
889	1101	// int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
890	1102	// asmlinkage long sys_epoll_wait(int epfd, struct epoll_event __user *events, int maxevents, int timeout);
	1103	pub const epoll_wait = @compileError("TODO: epoll_wait");
891	1104
892	1105	// epoll_ctl
893	1106	// int epoll_ctl(int epfd, int op, int fd, struct epoll_event *_Nullable event);
894	1107	// asmlinkage long sys_epoll_ctl(int epfd, int op, int fd, struct epoll_event __user *event);
	1108	pub const epoll_ctl = @compileError("TODO: epoll_ctl");
895	1109
896	1110	// tgkill
897	1111	// int tgkill(pid_t tgid, pid_t tid, int sig);
898	1112	// asmlinkage long sys_tgkill(pid_t tgid, pid_t pid, int sig);
	1113	pub const tgkill = @compileError("TODO: tgkill");
899	1114
900	1115	// utimes
901	1116	// int utimes(const char *filename, const struct timeval times[_Nullable 2]);
902	1117	// asmlinkage long sys_utimes(char __user filename, struct __kernel_old_timeval __user utimes);
	1118	pub const utimes = @compileError("TODO: utimes");
903	1119
904	1120	// mbind
905	1121	// long mbind(void addr[.len], unsigned long len, int mode, const unsigned long nodemask[(.maxnode + ULONG_WIDTH - 1) / ULONG_WIDTH], unsigned long maxnode, unsigned int flags);
906	1122	// asmlinkage long sys_mbind(unsigned long start, unsigned long len, unsigned long mode, const unsigned long __user *nmask, unsigned long maxnode, unsigned flags);
	1123	pub const mbind = @compileError("TODO: mbind");
907	1124
908	1125	// set_mempolicy
909	1126	// long set_mempolicy(int mode, const unsigned long *nodemask, unsigned long maxnode);
910	1127	// asmlinkage long sys_set_mempolicy(int mode, const unsigned long __user *nmask, unsigned long maxnode);
	1128	pub const set_mempolicy = @compileError("TODO: set_mempolicy");
911	1129
912	1130	// get_mempolicy
913	1131	// long get_mempolicy(int mode, unsigned long nodemask[(.maxnode + ULONG_WIDTH - 1) / ULONG_WIDTH], unsigned long maxnode, void addr, unsigned long flags);
914	1132	// asmlinkage long sys_get_mempolicy(int __user policy, unsigned long __user nmask, unsigned long maxnode, unsigned long addr, unsigned long flags);
	1133	pub const get_mempolicy = @compileError("TODO: get_mempolicy");
915	1134
916	1135	// mq_open
917	1136	// mqd_t mq_open(const char name, int oflag, mode_t mode, struct mq_attr attr);
918	1137	// asmlinkage long sys_mq_open(const char __user name, int oflag, umode_t mode, struct mq_attr __user attr);
	1138	pub const mq_open = @compileError("TODO: mq_open");
919	1139
920	1140	// mq_unlink
921	1141	// int mq_unlink(const char *name);
922	1142	// asmlinkage long sys_mq_unlink(const char __user *name);
	1143	pub const mq_unlink = @compileError("TODO: mq_unlink");
923	1144
924	1145	// mq_timedsend
925	1146	// int mq_timedsend(mqd_t mqdes, const char msg_ptr[.msg_len], size_t msg_len, unsigned int msg_prio, const struct timespec *abs_timeout);
926	1147	// asmlinkage long sys_mq_timedsend(mqd_t mqdes, const char __user msg_ptr, size_t msg_len, unsigned int msg_prio, const struct __kernel_timespec __user abs_timeout);
	1148	pub const mq_timedsend = @compileError("TODO: mq_timedsend");
927	1149
928	1150	// mq_timedreceive
929	1151	// ssize_t mq_timedreceive(mqd_t mqdes, char restrict msg_ptr[.msg_len], size_t msg_len, unsigned int restrict msg_prio, const struct timespec *restrict abs_timeout);
930	1152	// asmlinkage long sys_mq_timedreceive(mqd_t mqdes, char __user msg_ptr, size_t msg_len, unsigned int __user msg_prio, const struct __kernel_timespec __user *abs_timeout);
	1153	pub const mq_timedreceive = @compileError("TODO: mq_timedreceive");
931	1154
932	1155	// mq_notify
933	1156	// int mq_notify(mqd_t mqdes, const struct sigevent *sevp);
934	1157	// asmlinkage long sys_mq_notify(mqd_t mqdes, const struct sigevent __user *notification);
	1158	pub const mq_notify = @compileError("TODO: mq_notify");
935	1159
936	1160	// mq_getsetattr
937	1161	// int syscall(SYS_mq_getsetattr, mqd_t mqdes, const struct mq_attr newattr, struct mq_attr oldattr);
938	1162	// asmlinkage long sys_mq_getsetattr(mqd_t mqdes, const struct mq_attr __user mqstat, struct mq_attr __user omqstat);
	1163	pub const mq_getsetattr = @compileError("TODO: mq_getsetattr");
939	1164
940	1165	// kexec_load
941	1166	// long syscall(SYS_kexec_load, unsigned long entry, unsigned long nr_segments, struct kexec_segment *segments, unsigned long flags);
942	1167	// asmlinkage long sys_kexec_load(unsigned long entry, unsigned long nr_segments, struct kexec_segment __user *segments, unsigned long flags);
	1168	pub const kexec_load = @compileError("TODO: kexec_load");
943	1169
944	1170	// waitid
945	1171	// int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);
946	1172	// asmlinkage long sys_waitid(int which, pid_t pid, struct siginfo __user infop, int options, struct rusage __user ru);
	1173	pub const waitid = @compileError("TODO: waitid");
947	1174
948	1175	// add_key
949	1176	// key_serial_t add_key(const char type, const char description, const void payload[.plen], size_t plen, key_serial_t keyring);
950	1177	// asmlinkage long sys_add_key(const char __user _type, const char __user _description, const void __user *_payload, size_t plen, key_serial_t destringid);
	1178	pub const add_key = @compileError("TODO: add_key");
951	1179
952	1180	// request_key
953	1181	// key_serial_t request_key(const char type, const char description, const char *_Nullable callout_info, key_serial_t dest_keyring);
954	1182	// asmlinkage long sys_request_key(const char __user _type, const char __user _description, const char __user *_callout_info, key_serial_t destringid);
	1183	pub const request_key = @compileError("TODO: request_key");
955	1184
956	1185	// keyctl
957	1186	// long syscall(SYS_keyctl, int operation, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5);
958	1187	// asmlinkage long sys_keyctl(int cmd, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5);
	1188	pub const keyctl = @compileError("TODO: keyctl");
959	1189
960	1190	// ioprio_set
961	1191	// int syscall(SYS_ioprio_set, int which, int who, int ioprio);
962	1192	// asmlinkage long sys_ioprio_set(int which, int who, int ioprio);
	1193	pub const ioprio_set = @compileError("TODO: ioprio_set");
963	1194
964	1195	// ioprio_get
965	1196	// int syscall(SYS_ioprio_set, int which, int who, int ioprio);
966	1197	// asmlinkage long sys_ioprio_get(int which, int who);
	1198	pub const ioprio_get = @compileError("TODO: ioprio_get");
967	1199
968	1200	// inotify_init
969	1201	// int inotify_init(void);
970	1202	// asmlinkage long sys_inotify_init(void);
	1203	pub const inotify_init = @compileError("TODO: inotify_init");
971	1204
972	1205	// inotify_add_watch
973	1206	// int inotify_add_watch(int fd, const char *pathname, uint32_t mask);
974	1207	// asmlinkage long sys_inotify_add_watch(int fd, const char __user *path, u32 mask);
	1208	pub const inotify_add_watch = @compileError("TODO: inotify_add_watch");
975	1209
976	1210	// inotify_rm_watch
977	1211	// int inotify_rm_watch(int fd, int wd);
978	1212	// asmlinkage long sys_inotify_rm_watch(int fd, __s32 wd);
	1213	pub const inotify_rm_watch = @compileError("TODO: inotify_rm_watch");
979	1214
980	1215	// migrate_pages
981	1216	// long migrate_pages(int pid, unsigned long maxnode, const unsigned long old_nodes, const unsigned long new_nodes);
982	1217	// asmlinkage long sys_migrate_pages(pid_t pid, unsigned long maxnode, const unsigned long __user from, const unsigned long __user to);
	1218	pub const migrate_pages = @compileError("TODO: migrate_pages");
983	1219
984	1220	// openat
985	1221	// int openat(int dirfd, const char pathname, int flags, ... / mode_t mode */ );
986	1222	// asmlinkage long sys_openat(int dfd, const char __user *filename, int flags, umode_t mode);
	1223	pub const openat = @compileError("TODO: openat");
987	1224
988	1225	// mkdirat
989	1226	// int mkdirat(int dirfd, const char *pathname, mode_t mode);
990	1227	// asmlinkage long sys_mkdirat(int dfd, const char __user * pathname, umode_t mode);
	1228	pub const mkdirat = @compileError("TODO: mkdirat");
991	1229
992	1230	// mknodat
993	1231	// int mknodat(int dirfd, const char *pathname, mode_t mode, dev_t dev);
994	1232	// asmlinkage long sys_mknodat(int dfd, const char __user * filename, umode_t mode, unsigned dev);
	1233	pub const mknodat = @compileError("TODO: mknodat");
995	1234
996	1235	// fchownat
997	1236	// int fchownat(int dirfd, const char *pathname, uid_t owner, gid_t group, int flags);
998	1237	// asmlinkage long sys_fchownat(int dfd, const char __user *filename, uid_t user, gid_t group, int flag);
	1238	pub const fchownat = @compileError("TODO: fchownat");
999	1239
1000	1240	// futimesat
1001	1241	// [[deprecated]] int futimesat(int dirfd, const char *pathname, const struct timeval times[2]);
1002	1242	// asmlinkage long sys_futimesat(int dfd, const char __user filename, struct __kernel_old_timeval __user utimes);
	1243	pub const futimesat = @compileError("TODO: futimesat");
1003	1244
1004	1245	// fstatat64
1005	1246	// int fstatat(int dirfd, const char restrict pathname, struct stat restrict statbuf, int flags);
1006	1247	// asmlinkage long sys_fstatat64(int dfd, const char __user filename, struct stat64 __user statbuf, int flag);
	1248	pub const fstatat64 = @compileError("TODO: fstatat64");
1007	1249
1008	1250	// unlinkat
1009	1251	// int unlinkat(int dirfd, const char *pathname, int flags);
1010	1252	// asmlinkage long sys_unlinkat(int dfd, const char __user * pathname, int flag);
	1253	pub const unlinkat = @compileError("TODO: unlinkat");
1011	1254
1012	1255	// renameat
1013	1256	// int renameat(int olddirfd, const char oldpath, int newdirfd, const char newpath);
1014	1257	// asmlinkage long sys_renameat(int olddfd, const char __user * oldname, int newdfd, const char __user * newname);
	1258	pub const renameat = @compileError("TODO: renameat");
1015	1259
1016	1260	// linkat
1017	1261	// int linkat(int olddirfd, const char oldpath, int newdirfd, const char newpath, int flags);
1018	1262	// asmlinkage long sys_linkat(int olddfd, const char __user oldname, int newdfd, const char __user newname, int flags);
	1263	pub const linkat = @compileError("TODO: linkat");
1019	1264
1020	1265	// symlinkat
1021	1266	// int symlinkat(const char target, int newdirfd, const char linkpath);
1022	1267	// asmlinkage long sys_symlinkat(const char __user * oldname, int newdfd, const char __user * newname);
	1268	pub const symlinkat = @compileError("TODO: symlinkat");
1023	1269
1024	1270	// readlinkat
1025	1271	// ssize_t readlinkat(int dirfd, const char restrict pathname, char restrict buf, size_t bufsiz);
1026	1272	// asmlinkage long sys_readlinkat(int dfd, const char __user path, char __user buf, int bufsiz);
	1273	pub const readlinkat = @compileError("TODO: readlinkat");
1027	1274
1028	1275	// fchmodat
1029	1276	// int fchmodat(int dirfd, const char *pathname, mode_t mode, int flags);
1030	1277	// asmlinkage long sys_fchmodat(int dfd, const char __user *filename, umode_t mode);
	1278	pub const fchmodat = @compileError("TODO: fchmodat");
1031	1279
1032	1280	// faccessat
1033	1281	// int faccessat(int dirfd, const char *pathname, int mode, int flags);
1034	1282	// asmlinkage long sys_faccessat(int dfd, const char __user *filename, int mode);
	1283	pub const faccessat = @compileError("TODO: faccessat");
1035	1284
1036	1285	// pselect6
1037	1286	// int pselect(int nfds, fd_set _Nullable restrict readfds, fd_set _Nullable restrict writefds, fd_set _Nullable restrict exceptfds, const struct timespec _Nullable restrict timeout, const sigset_t *_Nullable restrict sigmask);
1038	1287	// asmlinkage long sys_pselect6(int, fd_set __user , fd_set __user , fd_set __user , struct __kernel_timespec __user , void __user *);
	1288	pub const pselect6 = @compileError("TODO: pselect6");
1039	1289
1040	1290	// ppoll
1041	1291	// int ppoll(struct pollfd fds, nfds_t nfds, const struct timespec _Nullable tmo_p, const sigset_t *_Nullable sigmask);
1042	1292	// asmlinkage long sys_ppoll(struct pollfd __user , unsigned int, struct __kernel_timespec __user , const sigset_t __user *, size_t);
	1293	pub const ppoll = @compileError("TODO: ppoll");
1043	1294
1044	1295	// unshare
1045	1296	// int unshare(int flags);
1046	1297	// asmlinkage long sys_unshare(unsigned long unshare_flags);
	1298	pub const unshare = @compileError("TODO: unshare");
1047	1299
1048	1300	// set_robust_list
1049	1301	// long syscall(SYS_set_robust_list, struct robust_list_head *head, size_t len);
1050	1302	// asmlinkage long sys_set_robust_list(struct robust_list_head __user *head, size_t len);
	1303	pub const set_robust_list = @compileError("TODO: set_robust_list");
1051	1304
1052	1305	// get_robust_list
1053	1306	// long syscall(SYS_get_robust_list, int pid, struct robust_list_head *head_ptr, size_t len_ptr);
1054	1307	// asmlinkage long sys_get_robust_list(int pid, struct robust_list_head __user * __user head_ptr, size_t __user len_ptr);
	1308	pub const get_robust_list = @compileError("TODO: get_robust_list");
1055	1309
1056	1310	// splice
1057	1311	// ssize_t splice(int fd_in, off_t _Nullable off_in, int fd_out, off_t _Nullable off_out, size_t len, unsigned int flags);
1058	1312	// asmlinkage long sys_splice(int fd_in, loff_t __user off_in, int fd_out, loff_t __user off_out, size_t len, unsigned int flags);
	1313	pub const splice = @compileError("TODO: splice");
1059	1314
1060	1315	// tee
1061	1316	// ssize_t tee(int fd_in, int fd_out, size_t len, unsigned int flags);
1062	1317	// asmlinkage long sys_tee(int fdin, int fdout, size_t len, unsigned int flags);
	1318	pub const tee = @compileError("TODO: tee");
1063	1319
1064	1320	// sync_file_range
1065	1321	// int sync_file_range(int fd, off_t offset, off_t nbytes, unsigned int flags);
1066	1322	// asmlinkage long sys_sync_file_range(int fd, loff_t offset, loff_t nbytes, unsigned int flags);
	1323	pub const sync_file_range = @compileError("TODO: sync_file_range");
1067	1324
1068	1325	// vmsplice
1069	1326	// ssize_t vmsplice(int fd, const struct iovec *iov, size_t nr_segs, unsigned int flags);
1070	1327	// asmlinkage long sys_vmsplice(int fd, const struct iovec __user *iov, unsigned long nr_segs, unsigned int flags);
	1328	pub const vmsplice = @compileError("TODO: vmsplice");
1071	1329
1072	1330	// move_pages
1073	1331	// long move_pages(int pid, unsigned long count, void *pages[.count], const int nodes[.count], int status[.count], int flags);
1074	1332	// asmlinkage long sys_move_pages(pid_t pid, unsigned long nr_pages, const void __user * __user pages, const int __user nodes, int __user *status, int flags);
	1333	pub const move_pages = @compileError("TODO: move_pages");
1075	1334
1076	1335	// utimensat
1077	1336	// int utimensat(int dirfd, const char *pathname, const struct timespec times[_Nullable 2], int flags);
1078	1337	// asmlinkage long sys_utimensat(int dfd, const char __user filename, struct __kernel_timespec __user utimes, int flags);
	1338	pub const utimensat = @compileError("TODO: utimensat");
1079	1339
1080	1340	// epoll_pwait
1081	1341	// int epoll_pwait(int epfd, struct epoll_event events, int maxevents, int timeout, const sigset_t _Nullable sigmask);
1082	1342	// asmlinkage long sys_epoll_pwait(int epfd, struct epoll_event __user events, int maxevents, int timeout, const sigset_t __user sigmask, size_t sigsetsize);
	1343	pub const epoll_pwait = @compileError("TODO: epoll_pwait");
1083	1344
1084	1345	// signalfd
1085	1346	// int signalfd(int fd, const sigset_t *mask, int flags);
1086	1347	// asmlinkage long sys_signalfd(int ufd, sigset_t __user *user_mask, size_t sizemask);
	1348	pub const signalfd = @compileError("TODO: signalfd");
1087	1349
1088	1350	// timerfd_create
1089	1351	// int timerfd_create(int clockid, int flags);
1090	1352	// asmlinkage long sys_timerfd_create(int clockid, int flags);
	1353	pub const timerfd_create = @compileError("TODO: timerfd_create");
1091	1354
1092	1355	// eventfd
1093	1356	// int eventfd(unsigned int initval, int flags);
1094	1357	// asmlinkage long sys_eventfd(unsigned int count);
	1358	pub const eventfd = @compileError("TODO: eventfd");
1095	1359
1096	1360	// fallocate
1097	1361	// int fallocate(int fd, int mode, off_t offset, off_t len);
1098	1362	// asmlinkage long sys_fallocate(int fd, int mode, loff_t offset, loff_t len);
	1363	pub const fallocate = @compileError("TODO: fallocate");
1099	1364
1100	1365	// timerfd_settime
1101	1366	// int timerfd_settime(int fd, int flags, const struct itimerspec new_value, struct itimerspec _Nullable old_value);
1102	1367	// asmlinkage long sys_timerfd_settime(int ufd, int flags, const struct __kernel_itimerspec __user utmr, struct __kernel_itimerspec __user otmr);
	1368	pub const timerfd_settime = @compileError("TODO: timerfd_settime");
1103	1369
1104	1370	// timerfd_gettime
1105	1371	// int timerfd_gettime(int fd, struct itimerspec *curr_value);
1106	1372	// asmlinkage long sys_timerfd_gettime(int ufd, struct __kernel_itimerspec __user *otmr);
	1373	pub const timerfd_gettime = @compileError("TODO: timerfd_gettime");
1107	1374
1108	1375	// accept4
1109	1376	// int accept4(int sockfd, struct sockaddr _Nullable restrict addr, socklen_t _Nullable restrict addrlen, int flags);
1110	1377	// asmlinkage long sys_accept4(int, struct sockaddr __user , int __user , int);
	1378	pub const accept4 = @compileError("TODO: accept4");
1111	1379
1112	1380	// signalfd4
1113	1381	// int signalfd(int fd, const sigset_t *mask, int flags);
1114	1382	// asmlinkage long sys_signalfd4(int ufd, sigset_t __user *user_mask, size_t sizemask, int flags);
	1383	pub const signalfd4 = @compileError("TODO: signalfd4");
1115	1384
1116	1385	// eventfd2
1117	1386	// int eventfd(unsigned int initval, int flags);
1118	1387	// asmlinkage long sys_eventfd2(unsigned int count, int flags);
	1388	pub const eventfd2 = @compileError("TODO: eventfd2");
1119	1389
1120	1390	// epoll_create1
1121	1391	// int epoll_create1(int flags);
1122	1392	// asmlinkage long sys_epoll_create1(int flags);
	1393	pub const epoll_create1 = @compileError("TODO: epoll_create1");
1123	1394
1124	1395	// dup3
1125	1396	// int dup3(int oldfd, int newfd, int flags);
1126	1397	// asmlinkage long sys_dup3(unsigned int oldfd, unsigned int newfd, int flags);
	1398	pub const dup3 = @compileError("TODO: dup3");
1127	1399
1128	1400	// pipe2
1129	1401	// int pipe2(int pipefd[2], int flags);
1130	1402	// asmlinkage long sys_pipe2(int __user *fildes, int flags);
	1403	pub const pipe2 = @compileError("TODO: pipe2");
1131	1404
1132	1405	// inotify_init1
1133	1406	// int inotify_init1(int flags);
1134	1407	// asmlinkage long sys_inotify_init1(int flags);
	1408	pub const inotify_init1 = @compileError("TODO: inotify_init1");
1135	1409
1136	1410	// preadv
1137	1411	// ssize_t preadv(int fd, const struct iovec *iov, int iovcnt, off_t offset);
1138	1412	// asmlinkage long sys_preadv(unsigned long fd, const struct iovec __user *vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h);
	1413	pub const preadv = @compileError("TODO: preadv");
1139	1414
1140	1415	// pwritev
1141	1416	// ssize_t pwritev(int fd, const struct iovec *iov, int iovcnt, off_t offset);
1142	1417	// asmlinkage long sys_pwritev(unsigned long fd, const struct iovec __user *vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h);
	1418	pub const pwritev = @compileError("TODO: pwritev");
1143	1419
1144	1420	// rt_tgsigqueueinfo
1145	1421	// int syscall(SYS_rt_tgsigqueueinfo, pid_t tgid, pid_t tid, int sig, siginfo_t *info);
1146	1422	// asmlinkage long sys_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t __user *uinfo);
	1423	pub const rt_tgsigqueueinfo = @compileError("TODO: rt_tgsigqueueinfo");
1147	1424
1148	1425	// perf_event_open
1149	1426	// int syscall(SYS_perf_event_open, struct perf_event_attr *attr, pid_t pid, int cpu, int group_fd, unsigned long flags);
1150	1427	// asmlinkage long sys_perf_event_open( struct perf_event_attr __user *attr_uptr, pid_t pid, int cpu, int group_fd, unsigned long flags);
	1428	pub const perf_event_open = @compileError("TODO: perf_event_open");
1151	1429
1152	1430	// recvmmsg
1153	1431	// int recvmmsg(int sockfd, struct mmsghdr msgvec, unsigned int vlen, int flags, struct timespec timeout);
1154	1432	// asmlinkage long sys_recvmmsg(int fd, struct mmsghdr __user msg, unsigned int vlen, unsigned flags, struct __kernel_timespec __user timeout);
	1433	pub const recvmmsg = @compileError("TODO: recvmmsg");
1155	1434
1156	1435	// fanotify_init
1157	1436	// int fanotify_init(unsigned int flags, unsigned int event_f_flags);
1158	1437	// asmlinkage long sys_fanotify_init(unsigned int flags, unsigned int event_f_flags);
	1438	pub const fanotify_init = @compileError("TODO: fanotify_init");
1159	1439
1160	1440	// fanotify_mark
1161	1441	// int fanotify_mark(int fanotify_fd, unsigned int flags, uint64_t mask, int dirfd, const char *_Nullable pathname);
1162	1442	// asmlinkage long sys_fanotify_mark(int fanotify_fd, unsigned int flags, u64 mask, int fd, const char __user *pathname);
	1443	pub const fanotify_mark = @compileError("TODO: fanotify_mark");
1163	1444
1164	1445	// prlimit64
1165	1446	// int prlimit(pid_t pid, int resource, const struct rlimit _Nullable new_limit, struct rlimit _Nullable old_limit);
1166	1447	// asmlinkage long sys_prlimit64(pid_t pid, unsigned int resource, const struct rlimit64 __user new_rlim, struct rlimit64 __user old_rlim);
	1448	pub const prlimit64 = @compileError("TODO: prlimit64");
1167	1449
1168	1450	// name_to_handle_at
1169	1451	// int name_to_handle_at(int dirfd, const char pathname, struct file_handle handle, int *mount_id, int flags);
1170	1452	// asmlinkage long sys_name_to_handle_at(int dfd, const char __user name, struct file_handle __user handle, void __user *mnt_id, int flag);
	1453	pub const name_to_handle_at = @compileError("TODO: name_to_handle_at");
1171	1454
1172	1455	// open_by_handle_at
1173	1456	// int open_by_handle_at(int mount_fd, struct file_handle *handle, int flags);
1174	1457	// asmlinkage long sys_open_by_handle_at(int mountdirfd, struct file_handle __user *handle, int flags);
	1458	pub const open_by_handle_at = @compileError("TODO: open_by_handle_at");
1175	1459
1176	1460	// clock_adjtime
1177	1461	// int clock_adjtime(clockid_t clk_id, struct timex *buf);
1178	1462	// asmlinkage long sys_clock_adjtime(clockid_t which_clock, struct __kernel_timex __user *tx);
	1463	pub const clock_adjtime = @compileError("TODO: clock_adjtime");
1179	1464
1180	1465	// syncfs
1181	1466	// int syncfs(int fd);
1182	1467	// asmlinkage long sys_syncfs(int fd);
	1468	pub const syncfs = @compileError("TODO: syncfs");
1183	1469
1184	1470	// sendmmsg
1185	1471	// int sendmmsg(int sockfd, struct mmsghdr *msgvec, unsigned int vlen, int flags);
1186	1472	// asmlinkage long sys_sendmmsg(int fd, struct mmsghdr __user *msg, unsigned int vlen, unsigned flags);
	1473	pub const sendmmsg = @compileError("TODO: sendmmsg");
1187	1474
1188	1475	// setns
1189	1476	// int setns(int fd, int nstype);
1190	1477	// asmlinkage long sys_setns(int fd, int nstype);
	1478	pub const setns = @compileError("TODO: setns");
1191	1479
1192	1480	// getcpu
1193	1481	// int getcpu(unsigned int _Nullable cpu, unsigned int _Nullable node);
1194	1482	// asmlinkage long sys_getcpu(unsigned __user cpu, unsigned __user node, struct getcpu_cache __user *cache);
	1483	pub const getcpu = @compileError("TODO: getcpu");
1195	1484
1196	1485	// process_vm_readv
1197	1486	// ssize_t process_vm_readv(pid_t pid, const struct iovec local_iov, unsigned long liovcnt, const struct iovec remote_iov, unsigned long riovcnt, unsigned long flags);
1198	1487	// asmlinkage long sys_process_vm_readv(pid_t pid, const struct iovec __user lvec, unsigned long liovcnt, const struct iovec __user rvec, unsigned long riovcnt, unsigned long flags);
	1488	pub const process_vm_readv = @compileError("TODO: process_vm_readv");
1199	1489
1200	1490	// process_vm_writev
1201	1491	// ssize_t process_vm_writev(pid_t pid, const struct iovec local_iov, unsigned long liovcnt, const struct iovec remote_iov, unsigned long riovcnt, unsigned long flags);
1202	1492	// asmlinkage long sys_process_vm_writev(pid_t pid, const struct iovec __user lvec, unsigned long liovcnt, const struct iovec __user rvec, unsigned long riovcnt, unsigned long flags);
	1493	pub const process_vm_writev = @compileError("TODO: process_vm_writev");
1203	1494
1204	1495	// kcmp
1205	1496	// int syscall(SYS_kcmp, pid_t pid1, pid_t pid2, int type, unsigned long idx1, unsigned long idx2);
1206	1497	// asmlinkage long sys_kcmp(pid_t pid1, pid_t pid2, int type, unsigned long idx1, unsigned long idx2);
	1498	pub const kcmp = @compileError("TODO: kcmp");
1207	1499
1208	1500	// finit_module
1209	1501	// int syscall(SYS_finit_module, int fd, const char *param_values, int flags);
1210	1502	// asmlinkage long sys_finit_module(int fd, const char __user *uargs, int flags);
	1503	pub const finit_module = @compileError("TODO: finit_module");
1211	1504
1212	1505	// sched_setattr
1213	1506	// int syscall(SYS_sched_setattr, pid_t pid, struct sched_attr *attr, unsigned int flags);
1214	1507	// asmlinkage long sys_sched_setattr(pid_t pid, struct sched_attr __user *attr, unsigned int flags);
	1508	pub const sched_setattr = @compileError("TODO: sched_setattr");
1215	1509
1216	1510	// sched_getattr
1217	1511	// int syscall(SYS_sched_getattr, pid_t pid, struct sched_attr *attr, unsigned int size, unsigned int flags);
1218	1512	// asmlinkage long sys_sched_getattr(pid_t pid, struct sched_attr __user *attr, unsigned int size, unsigned int flags);
	1513	pub const sched_getattr = @compileError("TODO: sched_getattr");
1219	1514
1220	1515	// renameat2
1221	1516	// int renameat2(int olddirfd, const char oldpath, int newdirfd, const char newpath, unsigned int flags);
1222	1517	// asmlinkage long sys_renameat2(int olddfd, const char __user oldname, int newdfd, const char __user newname, unsigned int flags);
	1518	pub const renameat2 = @compileError("TODO: renameat2");
1223	1519
1224	1520	// seccomp
1225	1521	// int syscall(SYS_seccomp, unsigned int operation, unsigned int flags, void *args);
1226	1522	// asmlinkage long sys_seccomp(unsigned int op, unsigned int flags, void __user *uargs);
	1523	pub const seccomp = @compileError("TODO: seccomp");
1227	1524
1228	1525	// getrandom
1229	1526	// ssize_t getrandom(void buf[.buflen], size_t buflen, unsigned int flags);
1230	1527	// asmlinkage long sys_getrandom(char __user *buf, size_t count, unsigned int flags);
	1528	pub const getrandom = @compileError("TODO: getrandom");
1231	1529
1232	1530	// memfd_create
1233	1531	// int memfd_create(const char *name, unsigned int flags);
1234	1532	// asmlinkage long sys_memfd_create(const char __user *uname_ptr, unsigned int flags);
	1533	pub const memfd_create = @compileError("TODO: memfd_create");
1235	1534
1236	1535	// kexec_file_load
1237	1536	// long syscall(SYS_kexec_file_load, int kernel_fd, int initrd_fd, unsigned long cmdline_len, const char *cmdline, unsigned long flags);
1238	1537	// asmlinkage long sys_kexec_file_load(int kernel_fd, int initrd_fd, unsigned long cmdline_len, const char __user *cmdline_ptr, unsigned long flags);
	1538	pub const kexec_file_load = @compileError("TODO: kexec_file_load");
1239	1539
1240	1540	// bpf
1241	1541	// int bpf(int cmd, union bpf_attr *attr, unsigned int size);
1242	1542	// asmlinkage long sys_bpf(int cmd, union bpf_attr __user *attr, unsigned int size);
	1543	pub const bpf = @compileError("TODO: bpf");
1243	1544
1244	1545	// execveat
1245	1546	// int execveat(int dirfd, const char pathname, char const _Nullable argv[], char *const _Nullable envp[], int flags);
1246	1547	// asmlinkage long sys_execveat(int dfd, const char __user filename, const char __user const __user argv, const char __user const __user *envp, int flags);
	1548	pub const execveat = @compileError("TODO: execveat");
1247	1549
1248	1550	// userfaultfd
1249	1551	// int syscall(SYS_userfaultfd, int flags);
1250	1552	// asmlinkage long sys_userfaultfd(int flags);
	1553	pub const userfaultfd = @compileError("TODO: userfaultfd");
1251	1554
1252	1555	// membarrier
1253	1556	// int syscall(SYS_membarrier, int cmd, unsigned int flags, int cpu_id);
1254	1557	// asmlinkage long sys_membarrier(int cmd, unsigned int flags, int cpu_id);
	1558	pub const membarrier = @compileError("TODO: membarrier");
1255	1559
1256	1560	// mlock2
1257	1561	// int mlock2(const void addr[.len], size_t len, unsigned int flags);
1258	1562	// asmlinkage long sys_mlock2(unsigned long start, size_t len, int flags);
	1563	pub const mlock2 = @compileError("TODO: mlock2");
1259	1564
1260	1565	// copy_file_range
1261	1566	// ssize_t copy_file_range(int fd_in, off_t _Nullable off_in, int fd_out, off_t _Nullable off_out, size_t len, unsigned int flags);
1262	1567	// asmlinkage long sys_copy_file_range(int fd_in, loff_t __user off_in, int fd_out, loff_t __user off_out, size_t len, unsigned int flags);
	1568	pub const copy_file_range = @compileError("TODO: copy_file_range");
1263	1569
1264	1570	// preadv2
1265	1571	// ssize_t preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
1266	1572	// asmlinkage long sys_preadv2(unsigned long fd, const struct iovec __user *vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h, rwf_t flags);
	1573	pub const preadv2 = @compileError("TODO: preadv2");
1267	1574
1268	1575	// pwritev2
1269	1576	// ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
1270	1577	// asmlinkage long sys_pwritev2(unsigned long fd, const struct iovec __user *vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h, rwf_t flags);
	1578	pub const pwritev2 = @compileError("TODO: pwritev2");
1271	1579
1272	1580	// pkey_mprotect
1273	1581	// int pkey_mprotect(void addr[.len], size_t len, int prot, int pkey);
1274	1582	// asmlinkage long sys_pkey_mprotect(unsigned long start, size_t len, unsigned long prot, int pkey);
	1583	pub const pkey_mprotect = @compileError("TODO: pkey_mprotect");
1275	1584
1276	1585	// pkey_alloc
1277	1586	// int pkey_alloc(unsigned int flags, unsigned int access_rights);
1278	1587	// asmlinkage long sys_pkey_alloc(unsigned long flags, unsigned long init_val);
	1588	pub const pkey_alloc = @compileError("TODO: pkey_alloc");
1279	1589
1280	1590	// pkey_free
1281	1591	// int pkey_free(int pkey);
1282	1592	// asmlinkage long sys_pkey_free(int pkey);
	1593	pub const pkey_free = @compileError("TODO: pkey_free");
1283	1594
1284	1595	// statx
1285	1596	// int statx(int dirfd, const char restrict pathname, int flags, unsigned int mask, struct statx restrict statxbuf);
1286	1597	// asmlinkage long sys_statx(int dfd, const char __user path, unsigned flags, unsigned mask, struct statx __user buffer);
	1598	pub const statx = @compileError("TODO: statx");
1287	1599
1288	1600	// io_pgetevents
1289	1601	//
1290	1602	// asmlinkage long sys_io_pgetevents(aio_context_t ctx_id, long min_nr, long nr, struct io_event __user events, struct __kernel_timespec __user timeout, const struct __aio_sigset __user *sig);
	1603	pub const io_pgetevents = @compileError("TODO: io_pgetevents");
1291	1604
1292	1605	// rseq
1293	1606	//
1294	1607	// asmlinkage long sys_rseq(struct rseq __user *rseq, uint32_t rseq_len, int flags, uint32_t sig);
	1608	pub const rseq = @compileError("TODO: rseq");
1295	1609
1296	1610	// pidfd_send_signal
1297	1611	// int syscall(SYS_pidfd_send_signal, int pidfd, int sig, siginfo_t *_Nullable info, unsigned int flags);
...	...	@@ -1299,127 +1613,159 @@ pub fn write(fd: c_int, buf: []const u8) errno.Error!usize {
1299	1613	// io_uring_setup
1300	1614	// int io_uring_setup(u32 entries, struct io_uring_params *p);
1301	1615	// asmlinkage long sys_io_uring_setup(u32 entries, struct io_uring_params __user *p);
	1616	pub const io_uring_setup = @compileError("TODO: io_uring_setup");
1302	1617
1303	1618	// io_uring_enter
1304	1619	// int io_uring_enter(unsigned int fd, unsigned int to_submit, unsigned int min_complete, unsigned int flags, sigset_t *sig);
1305	1620	// asmlinkage long sys_io_uring_enter(unsigned int fd, u32 to_submit, u32 min_complete, u32 flags, const void __user *argp, size_t argsz);
	1621	pub const io_uring_enter = @compileError("TODO: io_uring_enter");
1306	1622
1307	1623	// io_uring_register
1308	1624	// int io_uring_register(unsigned int fd, unsigned int opcode, void *arg, unsigned int nr_args);
1309	1625	// asmlinkage long sys_io_uring_register(unsigned int fd, unsigned int op, void __user *arg, unsigned int nr_args);
	1626	pub const io_uring_register = @compileError("TODO: io_uring_register");
1310	1627
1311	1628	// open_tree
1312	1629	//
1313	1630	// asmlinkage long sys_open_tree(int dfd, const char __user *path, unsigned flags);
	1631	pub const open_tree = @compileError("TODO: open_tree");
1314	1632
1315	1633	// move_mount
1316	1634	//
1317	1635	// asmlinkage long sys_move_mount(int from_dfd, const char __user from_path, int to_dfd, const char __user to_path, unsigned int ms_flags);
	1636	pub const move_mount = @compileError("TODO: move_mount");
1318	1637
1319	1638	// fsopen
1320	1639	//
1321	1640	// asmlinkage long sys_fsopen(const char __user *fs_name, unsigned int flags);
	1641	pub const fsopen = @compileError("TODO: fsopen");
1322	1642
1323	1643	// fsconfig
1324	1644	//
1325	1645	// asmlinkage long sys_fsconfig(int fs_fd, unsigned int cmd, const char __user key, const void __user value, int aux);
	1646	pub const fsconfig = @compileError("TODO: fsconfig");
1326	1647
1327	1648	// fsmount
1328	1649	//
1329	1650	// asmlinkage long sys_fsmount(int fs_fd, unsigned int flags, unsigned int ms_flags);
	1651	pub const fsmount = @compileError("TODO: fsmount");
1330	1652
1331	1653	// fspick
1332	1654	//
1333	1655	// asmlinkage long sys_fspick(int dfd, const char __user *path, unsigned int flags);
	1656	pub const fspick = @compileError("TODO: fspick");
1334	1657
1335	1658	// pidfd_open
1336	1659	// int syscall(SYS_pidfd_open, pid_t pid, unsigned int flags);
1337	1660	// asmlinkage long sys_pidfd_open(pid_t pid, unsigned int flags);
	1661	pub const pidfd_open = @compileError("TODO: pidfd_open");
1338	1662
1339	1663	// clone3
1340	1664	// long syscall(SYS_clone3, struct clone_args *cl_args, size_t size);
1341	1665	// asmlinkage long sys_clone3(struct clone_args __user *uargs, size_t size);
	1666	pub const clone3 = @compileError("TODO: clone3");
1342	1667
1343	1668	// close_range
1344	1669	// int close_range(unsigned int first, unsigned int last, int flags);
1345	1670	// asmlinkage long sys_close_range(unsigned int fd, unsigned int max_fd, unsigned int flags);
	1671	pub const close_range = @compileError("TODO: close_range");
1346	1672
1347	1673	// openat2
1348	1674	// int openat2(int dirfd, const char pathname, const struct open_how how, size_t size);
1349	1675	// asmlinkage long sys_openat2(int dfd, const char __user filename, struct open_how __user how, size_t size);
	1676	pub const openat2 = @compileError("TODO: openat2");
1350	1677
1351	1678	// pidfd_getfd
1352	1679	// int syscall(SYS_pidfd_getfd, int pidfd, int targetfd, unsigned int flags);
1353	1680	// asmlinkage long sys_pidfd_getfd(int pidfd, int fd, unsigned int flags);
	1681	pub const pidfd_getfd = @compileError("TODO: pidfd_getfd");
1354	1682
1355	1683	// faccessat2
1356	1684	// int syscall(SYS_faccessat2, int dirfd, const char *pathname, int mode, int flags);
1357	1685	// asmlinkage long sys_faccessat2(int dfd, const char __user *filename, int mode, int flags);
	1686	pub const faccessat2 = @compileError("TODO: faccessat2");
1358	1687
1359	1688	// process_madvise
1360	1689	// ssize_t process_madvise(int pidfd, const struct iovec iovec[.n], size_t n, int advice, unsigned int flags);
1361	1690	// asmlinkage long sys_process_madvise(int pidfd, const struct iovec __user *vec, size_t vlen, int behavior, unsigned int flags);
	1691	pub const process_madvise = @compileError("TODO: process_madvise");
1362	1692
1363	1693	// epoll_pwait2
1364	1694	// int epoll_pwait2(int epfd, struct epoll_event events, int maxevents, const struct timespec _Nullable timeout, const sigset_t *_Nullable sigmask);
1365	1695	// asmlinkage long sys_epoll_pwait2(int epfd, struct epoll_event __user events, int maxevents, const struct __kernel_timespec __user timeout, const sigset_t __user *sigmask, size_t sigsetsize);
	1696	pub const epoll_pwait2 = @compileError("TODO: epoll_pwait2");
1366	1697
1367	1698	// mount_setattr
1368	1699	// int syscall(SYS_mount_setattr, int dirfd, const char pathname, unsigned int flags, struct mount_attr attr, size_t size);
1369	1700	// asmlinkage long sys_mount_setattr(int dfd, const char __user path, unsigned int flags, struct mount_attr __user uattr, size_t usize);
	1701	pub const mount_setattr = @compileError("TODO: mount_setattr");
1370	1702
1371	1703	// quotactl_fd
1372	1704	// int quotactl(int op, const char *_Nullable special, int id, caddr_t addr);
1373	1705	// asmlinkage long sys_quotactl_fd(unsigned int fd, unsigned int cmd, qid_t id, void __user *addr);
	1706	pub const quotactl_fd = @compileError("TODO: quotactl_fd");
1374	1707
1375	1708	// landlock_create_ruleset
1376	1709	// int syscall(SYS_landlock_create_ruleset, const struct landlock_ruleset_attr *attr, size_t size , uint32_t flags);
1377	1710	// asmlinkage long sys_landlock_create_ruleset(const struct landlock_ruleset_attr __user *attr, size_t size, __u32 flags);
	1711	pub const landlock_create_ruleset = @compileError("TODO: landlock_create_ruleset");
1378	1712
1379	1713	// landlock_add_rule
1380	1714	// int syscall(SYS_landlock_add_rule, int ruleset_fd, enum landlock_rule_type rule_type, const void *rule_attr, uint32_t flags);
1381	1715	// asmlinkage long sys_landlock_add_rule(int ruleset_fd, enum landlock_rule_type rule_type, const void __user *rule_attr, __u32 flags);
	1716	pub const landlock_add_rule = @compileError("TODO: landlock_add_rule");
1382	1717
1383	1718	// landlock_restrict_self
1384	1719	// int syscall(SYS_landlock_restrict_self, int ruleset_fd, uint32_t flags);
1385	1720	// asmlinkage long sys_landlock_restrict_self(int ruleset_fd, __u32 flags);
	1721	pub const landlock_restrict_self = @compileError("TODO: landlock_restrict_self");
1386	1722
1387	1723	// memfd_secret
1388	1724	// int syscall(SYS_memfd_secret, unsigned int flags);
1389	1725	// asmlinkage long sys_memfd_secret(unsigned int flags);
	1726	pub const memfd_secret = @compileError("TODO: memfd_secret");
1390	1727
1391	1728	// process_mrelease
1392	1729	//
1393	1730	// asmlinkage long sys_process_mrelease(int pidfd, unsigned int flags);
	1731	pub const process_mrelease = @compileError("TODO: process_mrelease");
1394	1732
1395	1733	// futex_waitv
1396	1734	//
1397	1735	// asmlinkage long sys_futex_waitv(struct futex_waitv __user waiters, unsigned int nr_futexes, unsigned int flags, struct __kernel_timespec __user timeout, clockid_t clockid);
	1736	pub const futex_waitv = @compileError("TODO: futex_waitv");
1398	1737
1399	1738	// set_mempolicy_home_node
1400	1739	//
1401	1740	// asmlinkage long sys_set_mempolicy_home_node(unsigned long start, unsigned long len, unsigned long home_node, unsigned long flags);
	1741	pub const set_mempolicy_home_node = @compileError("TODO: set_mempolicy_home_node");
1402	1742
1403	1743	// cachestat
1404	1744	//
1405	1745	// asmlinkage long sys_cachestat(unsigned int fd, struct cachestat_range __user cstat_range, struct cachestat __user cstat, unsigned int flags);
	1746	pub const cachestat = @compileError("TODO: cachestat");
1406	1747
1407	1748	// fchmodat2
1408	1749	//
1409	1750	// asmlinkage long sys_fchmodat2(int dfd, const char __user *filename, umode_t mode, unsigned int flags);
	1751	pub const fchmodat2 = @compileError("TODO: fchmodat2");
1410	1752
1411	1753	// map_shadow_stack
1412	1754	//
1413	1755	// asmlinkage long sys_map_shadow_stack(unsigned long addr, unsigned long size, unsigned int flags);
	1756	pub const map_shadow_stack = @compileError("TODO: map_shadow_stack");
1414	1757
1415	1758	// futex_wake
1416	1759	//
1417	1760	// asmlinkage long sys_futex_wake(void __user *uaddr, unsigned long mask, int nr, unsigned int flags);
	1761	pub const futex_wake = @compileError("TODO: futex_wake");
1418	1762
1419	1763	// futex_wait
1420	1764	//
1421	1765	// asmlinkage long sys_futex_wait(void __user uaddr, unsigned long val, unsigned long mask, unsigned int flags, struct __kernel_timespec __user timespec, clockid_t clockid);
	1766	pub const futex_wait = @compileError("TODO: futex_wait");
1422	1767
1423	1768	// futex_requeue
1424	1769	//
1425	1770	// asmlinkage long sys_futex_requeue(struct futex_waitv __user *waiters, unsigned int flags, int nr_wake, int nr_requeue);
	1771	pub const futex_requeue = @compileError("TODO: futex_requeue");