2011-11-11 23:55:49 +00:00
|
|
|
#
|
|
|
|
|
# 64-bit system call numbers and entry vectors
|
|
|
|
|
#
|
|
|
|
|
# The format is:
|
|
|
|
|
# <number> <abi> <name> <entry point>
|
|
|
|
|
#
|
2018-04-09 10:51:44 +00:00
|
|
|
# The __x64_sys_*() stubs are created on-the-fly for sys_*() system calls
|
|
|
|
|
#
|
2012-02-14 22:18:50 +00:00
|
|
|
# The abi is "common", "64" or "x32" for this file.
|
2011-11-11 23:55:49 +00:00
|
|
|
#
|
2018-04-09 10:51:44 +00:00
|
|
|
0 common read __x64_sys_read
|
|
|
|
|
1 common write __x64_sys_write
|
|
|
|
|
2 common open __x64_sys_open
|
|
|
|
|
3 common close __x64_sys_close
|
|
|
|
|
4 common stat __x64_sys_newstat
|
|
|
|
|
5 common fstat __x64_sys_newfstat
|
|
|
|
|
6 common lstat __x64_sys_newlstat
|
|
|
|
|
7 common poll __x64_sys_poll
|
|
|
|
|
8 common lseek __x64_sys_lseek
|
|
|
|
|
9 common mmap __x64_sys_mmap
|
|
|
|
|
10 common mprotect __x64_sys_mprotect
|
|
|
|
|
11 common munmap __x64_sys_munmap
|
|
|
|
|
12 common brk __x64_sys_brk
|
|
|
|
|
13 64 rt_sigaction __x64_sys_rt_sigaction
|
|
|
|
|
14 common rt_sigprocmask __x64_sys_rt_sigprocmask
|
|
|
|
|
15 64 rt_sigreturn __x64_sys_rt_sigreturn/ptregs
|
|
|
|
|
16 64 ioctl __x64_sys_ioctl
|
|
|
|
|
17 common pread64 __x64_sys_pread64
|
|
|
|
|
18 common pwrite64 __x64_sys_pwrite64
|
|
|
|
|
19 64 readv __x64_sys_readv
|
|
|
|
|
20 64 writev __x64_sys_writev
|
|
|
|
|
21 common access __x64_sys_access
|
|
|
|
|
22 common pipe __x64_sys_pipe
|
|
|
|
|
23 common select __x64_sys_select
|
|
|
|
|
24 common sched_yield __x64_sys_sched_yield
|
|
|
|
|
25 common mremap __x64_sys_mremap
|
|
|
|
|
26 common msync __x64_sys_msync
|
|
|
|
|
27 common mincore __x64_sys_mincore
|
|
|
|
|
28 common madvise __x64_sys_madvise
|
|
|
|
|
29 common shmget __x64_sys_shmget
|
|
|
|
|
30 common shmat __x64_sys_shmat
|
|
|
|
|
31 common shmctl __x64_sys_shmctl
|
|
|
|
|
32 common dup __x64_sys_dup
|
|
|
|
|
33 common dup2 __x64_sys_dup2
|
|
|
|
|
34 common pause __x64_sys_pause
|
|
|
|
|
35 common nanosleep __x64_sys_nanosleep
|
|
|
|
|
36 common getitimer __x64_sys_getitimer
|
|
|
|
|
37 common alarm __x64_sys_alarm
|
|
|
|
|
38 common setitimer __x64_sys_setitimer
|
|
|
|
|
39 common getpid __x64_sys_getpid
|
|
|
|
|
40 common sendfile __x64_sys_sendfile64
|
|
|
|
|
41 common socket __x64_sys_socket
|
|
|
|
|
42 common connect __x64_sys_connect
|
|
|
|
|
43 common accept __x64_sys_accept
|
|
|
|
|
44 common sendto __x64_sys_sendto
|
|
|
|
|
45 64 recvfrom __x64_sys_recvfrom
|
|
|
|
|
46 64 sendmsg __x64_sys_sendmsg
|
|
|
|
|
47 64 recvmsg __x64_sys_recvmsg
|
|
|
|
|
48 common shutdown __x64_sys_shutdown
|
|
|
|
|
49 common bind __x64_sys_bind
|
|
|
|
|
50 common listen __x64_sys_listen
|
|
|
|
|
51 common getsockname __x64_sys_getsockname
|
|
|
|
|
52 common getpeername __x64_sys_getpeername
|
|
|
|
|
53 common socketpair __x64_sys_socketpair
|
|
|
|
|
54 64 setsockopt __x64_sys_setsockopt
|
|
|
|
|
55 64 getsockopt __x64_sys_getsockopt
|
|
|
|
|
56 common clone __x64_sys_clone/ptregs
|
|
|
|
|
57 common fork __x64_sys_fork/ptregs
|
|
|
|
|
58 common vfork __x64_sys_vfork/ptregs
|
|
|
|
|
59 64 execve __x64_sys_execve/ptregs
|
|
|
|
|
60 common exit __x64_sys_exit
|
|
|
|
|
61 common wait4 __x64_sys_wait4
|
|
|
|
|
62 common kill __x64_sys_kill
|
|
|
|
|
63 common uname __x64_sys_newuname
|
|
|
|
|
64 common semget __x64_sys_semget
|
|
|
|
|
65 common semop __x64_sys_semop
|
|
|
|
|
66 common semctl __x64_sys_semctl
|
|
|
|
|
67 common shmdt __x64_sys_shmdt
|
|
|
|
|
68 common msgget __x64_sys_msgget
|
|
|
|
|
69 common msgsnd __x64_sys_msgsnd
|
|
|
|
|
70 common msgrcv __x64_sys_msgrcv
|
|
|
|
|
71 common msgctl __x64_sys_msgctl
|
|
|
|
|
72 common fcntl __x64_sys_fcntl
|
|
|
|
|
73 common flock __x64_sys_flock
|
|
|
|
|
74 common fsync __x64_sys_fsync
|
|
|
|
|
75 common fdatasync __x64_sys_fdatasync
|
|
|
|
|
76 common truncate __x64_sys_truncate
|
|
|
|
|
77 common ftruncate __x64_sys_ftruncate
|
|
|
|
|
78 common getdents __x64_sys_getdents
|
|
|
|
|
79 common getcwd __x64_sys_getcwd
|
|
|
|
|
80 common chdir __x64_sys_chdir
|
|
|
|
|
81 common fchdir __x64_sys_fchdir
|
|
|
|
|
82 common rename __x64_sys_rename
|
|
|
|
|
83 common mkdir __x64_sys_mkdir
|
|
|
|
|
84 common rmdir __x64_sys_rmdir
|
|
|
|
|
85 common creat __x64_sys_creat
|
|
|
|
|
86 common link __x64_sys_link
|
|
|
|
|
87 common unlink __x64_sys_unlink
|
|
|
|
|
88 common symlink __x64_sys_symlink
|
|
|
|
|
89 common readlink __x64_sys_readlink
|
|
|
|
|
90 common chmod __x64_sys_chmod
|
|
|
|
|
91 common fchmod __x64_sys_fchmod
|
|
|
|
|
92 common chown __x64_sys_chown
|
|
|
|
|
93 common fchown __x64_sys_fchown
|
|
|
|
|
94 common lchown __x64_sys_lchown
|
|
|
|
|
95 common umask __x64_sys_umask
|
|
|
|
|
96 common gettimeofday __x64_sys_gettimeofday
|
|
|
|
|
97 common getrlimit __x64_sys_getrlimit
|
|
|
|
|
98 common getrusage __x64_sys_getrusage
|
|
|
|
|
99 common sysinfo __x64_sys_sysinfo
|
|
|
|
|
100 common times __x64_sys_times
|
|
|
|
|
101 64 ptrace __x64_sys_ptrace
|
|
|
|
|
102 common getuid __x64_sys_getuid
|
|
|
|
|
103 common syslog __x64_sys_syslog
|
|
|
|
|
104 common getgid __x64_sys_getgid
|
|
|
|
|
105 common setuid __x64_sys_setuid
|
|
|
|
|
106 common setgid __x64_sys_setgid
|
|
|
|
|
107 common geteuid __x64_sys_geteuid
|
|
|
|
|
108 common getegid __x64_sys_getegid
|
|
|
|
|
109 common setpgid __x64_sys_setpgid
|
|
|
|
|
110 common getppid __x64_sys_getppid
|
|
|
|
|
111 common getpgrp __x64_sys_getpgrp
|
|
|
|
|
112 common setsid __x64_sys_setsid
|
|
|
|
|
113 common setreuid __x64_sys_setreuid
|
|
|
|
|
114 common setregid __x64_sys_setregid
|
|
|
|
|
115 common getgroups __x64_sys_getgroups
|
|
|
|
|
116 common setgroups __x64_sys_setgroups
|
|
|
|
|
117 common setresuid __x64_sys_setresuid
|
|
|
|
|
118 common getresuid __x64_sys_getresuid
|
|
|
|
|
119 common setresgid __x64_sys_setresgid
|
|
|
|
|
120 common getresgid __x64_sys_getresgid
|
|
|
|
|
121 common getpgid __x64_sys_getpgid
|
|
|
|
|
122 common setfsuid __x64_sys_setfsuid
|
|
|
|
|
123 common setfsgid __x64_sys_setfsgid
|
|
|
|
|
124 common getsid __x64_sys_getsid
|
|
|
|
|
125 common capget __x64_sys_capget
|
|
|
|
|
126 common capset __x64_sys_capset
|
|
|
|
|
127 64 rt_sigpending __x64_sys_rt_sigpending
|
|
|
|
|
128 64 rt_sigtimedwait __x64_sys_rt_sigtimedwait
|
|
|
|
|
129 64 rt_sigqueueinfo __x64_sys_rt_sigqueueinfo
|
|
|
|
|
130 common rt_sigsuspend __x64_sys_rt_sigsuspend
|
|
|
|
|
131 64 sigaltstack __x64_sys_sigaltstack
|
|
|
|
|
132 common utime __x64_sys_utime
|
|
|
|
|
133 common mknod __x64_sys_mknod
|
2011-11-11 23:55:49 +00:00
|
|
|
134 64 uselib
|
2018-04-09 10:51:44 +00:00
|
|
|
135 common personality __x64_sys_personality
|
|
|
|
|
136 common ustat __x64_sys_ustat
|
|
|
|
|
137 common statfs __x64_sys_statfs
|
|
|
|
|
138 common fstatfs __x64_sys_fstatfs
|
|
|
|
|
139 common sysfs __x64_sys_sysfs
|
|
|
|
|
140 common getpriority __x64_sys_getpriority
|
|
|
|
|
141 common setpriority __x64_sys_setpriority
|
|
|
|
|
142 common sched_setparam __x64_sys_sched_setparam
|
|
|
|
|
143 common sched_getparam __x64_sys_sched_getparam
|
|
|
|
|
144 common sched_setscheduler __x64_sys_sched_setscheduler
|
|
|
|
|
145 common sched_getscheduler __x64_sys_sched_getscheduler
|
|
|
|
|
146 common sched_get_priority_max __x64_sys_sched_get_priority_max
|
|
|
|
|
147 common sched_get_priority_min __x64_sys_sched_get_priority_min
|
|
|
|
|
148 common sched_rr_get_interval __x64_sys_sched_rr_get_interval
|
|
|
|
|
149 common mlock __x64_sys_mlock
|
|
|
|
|
150 common munlock __x64_sys_munlock
|
|
|
|
|
151 common mlockall __x64_sys_mlockall
|
|
|
|
|
152 common munlockall __x64_sys_munlockall
|
|
|
|
|
153 common vhangup __x64_sys_vhangup
|
|
|
|
|
154 common modify_ldt __x64_sys_modify_ldt
|
|
|
|
|
155 common pivot_root __x64_sys_pivot_root
|
|
|
|
|
156 64 _sysctl __x64_sys_sysctl
|
|
|
|
|
157 common prctl __x64_sys_prctl
|
|
|
|
|
158 common arch_prctl __x64_sys_arch_prctl
|
|
|
|
|
159 common adjtimex __x64_sys_adjtimex
|
|
|
|
|
160 common setrlimit __x64_sys_setrlimit
|
|
|
|
|
161 common chroot __x64_sys_chroot
|
|
|
|
|
162 common sync __x64_sys_sync
|
|
|
|
|
163 common acct __x64_sys_acct
|
|
|
|
|
164 common settimeofday __x64_sys_settimeofday
|
|
|
|
|
165 common mount __x64_sys_mount
|
|
|
|
|
166 common umount2 __x64_sys_umount
|
|
|
|
|
167 common swapon __x64_sys_swapon
|
|
|
|
|
168 common swapoff __x64_sys_swapoff
|
|
|
|
|
169 common reboot __x64_sys_reboot
|
|
|
|
|
170 common sethostname __x64_sys_sethostname
|
|
|
|
|
171 common setdomainname __x64_sys_setdomainname
|
|
|
|
|
172 common iopl __x64_sys_iopl/ptregs
|
|
|
|
|
173 common ioperm __x64_sys_ioperm
|
2011-11-11 23:55:49 +00:00
|
|
|
174 64 create_module
|
2018-04-09 10:51:44 +00:00
|
|
|
175 common init_module __x64_sys_init_module
|
|
|
|
|
176 common delete_module __x64_sys_delete_module
|
2011-11-11 23:55:49 +00:00
|
|
|
177 64 get_kernel_syms
|
|
|
|
|
178 64 query_module
|
2018-04-09 10:51:44 +00:00
|
|
|
179 common quotactl __x64_sys_quotactl
|
2011-11-11 23:55:49 +00:00
|
|
|
180 64 nfsservctl
|
2012-02-14 22:18:50 +00:00
|
|
|
181 common getpmsg
|
|
|
|
|
182 common putpmsg
|
|
|
|
|
183 common afs_syscall
|
|
|
|
|
184 common tuxcall
|
|
|
|
|
185 common security
|
2018-04-09 10:51:44 +00:00
|
|
|
186 common gettid __x64_sys_gettid
|
|
|
|
|
187 common readahead __x64_sys_readahead
|
|
|
|
|
188 common setxattr __x64_sys_setxattr
|
|
|
|
|
189 common lsetxattr __x64_sys_lsetxattr
|
|
|
|
|
190 common fsetxattr __x64_sys_fsetxattr
|
|
|
|
|
191 common getxattr __x64_sys_getxattr
|
|
|
|
|
192 common lgetxattr __x64_sys_lgetxattr
|
|
|
|
|
193 common fgetxattr __x64_sys_fgetxattr
|
|
|
|
|
194 common listxattr __x64_sys_listxattr
|
|
|
|
|
195 common llistxattr __x64_sys_llistxattr
|
|
|
|
|
196 common flistxattr __x64_sys_flistxattr
|
|
|
|
|
197 common removexattr __x64_sys_removexattr
|
|
|
|
|
198 common lremovexattr __x64_sys_lremovexattr
|
|
|
|
|
199 common fremovexattr __x64_sys_fremovexattr
|
|
|
|
|
200 common tkill __x64_sys_tkill
|
|
|
|
|
201 common time __x64_sys_time
|
|
|
|
|
202 common futex __x64_sys_futex
|
|
|
|
|
203 common sched_setaffinity __x64_sys_sched_setaffinity
|
|
|
|
|
204 common sched_getaffinity __x64_sys_sched_getaffinity
|
2011-11-11 23:55:49 +00:00
|
|
|
205 64 set_thread_area
|
2018-04-09 10:51:44 +00:00
|
|
|
206 64 io_setup __x64_sys_io_setup
|
|
|
|
|
207 common io_destroy __x64_sys_io_destroy
|
|
|
|
|
208 common io_getevents __x64_sys_io_getevents
|
|
|
|
|
209 64 io_submit __x64_sys_io_submit
|
|
|
|
|
210 common io_cancel __x64_sys_io_cancel
|
2011-11-11 23:55:49 +00:00
|
|
|
211 64 get_thread_area
|
2018-04-09 10:51:44 +00:00
|
|
|
212 common lookup_dcookie __x64_sys_lookup_dcookie
|
|
|
|
|
213 common epoll_create __x64_sys_epoll_create
|
2011-11-11 23:55:49 +00:00
|
|
|
214 64 epoll_ctl_old
|
|
|
|
|
215 64 epoll_wait_old
|
2018-04-09 10:51:44 +00:00
|
|
|
216 common remap_file_pages __x64_sys_remap_file_pages
|
|
|
|
|
217 common getdents64 __x64_sys_getdents64
|
|
|
|
|
218 common set_tid_address __x64_sys_set_tid_address
|
|
|
|
|
219 common restart_syscall __x64_sys_restart_syscall
|
|
|
|
|
220 common semtimedop __x64_sys_semtimedop
|
|
|
|
|
221 common fadvise64 __x64_sys_fadvise64
|
|
|
|
|
222 64 timer_create __x64_sys_timer_create
|
|
|
|
|
223 common timer_settime __x64_sys_timer_settime
|
|
|
|
|
224 common timer_gettime __x64_sys_timer_gettime
|
|
|
|
|
225 common timer_getoverrun __x64_sys_timer_getoverrun
|
|
|
|
|
226 common timer_delete __x64_sys_timer_delete
|
|
|
|
|
227 common clock_settime __x64_sys_clock_settime
|
|
|
|
|
228 common clock_gettime __x64_sys_clock_gettime
|
|
|
|
|
229 common clock_getres __x64_sys_clock_getres
|
|
|
|
|
230 common clock_nanosleep __x64_sys_clock_nanosleep
|
|
|
|
|
231 common exit_group __x64_sys_exit_group
|
|
|
|
|
232 common epoll_wait __x64_sys_epoll_wait
|
|
|
|
|
233 common epoll_ctl __x64_sys_epoll_ctl
|
|
|
|
|
234 common tgkill __x64_sys_tgkill
|
|
|
|
|
235 common utimes __x64_sys_utimes
|
2011-11-11 23:55:49 +00:00
|
|
|
236 64 vserver
|
2018-04-09 10:51:44 +00:00
|
|
|
237 common mbind __x64_sys_mbind
|
|
|
|
|
238 common set_mempolicy __x64_sys_set_mempolicy
|
|
|
|
|
239 common get_mempolicy __x64_sys_get_mempolicy
|
|
|
|
|
240 common mq_open __x64_sys_mq_open
|
|
|
|
|
241 common mq_unlink __x64_sys_mq_unlink
|
|
|
|
|
242 common mq_timedsend __x64_sys_mq_timedsend
|
|
|
|
|
243 common mq_timedreceive __x64_sys_mq_timedreceive
|
|
|
|
|
244 64 mq_notify __x64_sys_mq_notify
|
|
|
|
|
245 common mq_getsetattr __x64_sys_mq_getsetattr
|
|
|
|
|
246 64 kexec_load __x64_sys_kexec_load
|
|
|
|
|
247 64 waitid __x64_sys_waitid
|
|
|
|
|
248 common add_key __x64_sys_add_key
|
|
|
|
|
249 common request_key __x64_sys_request_key
|
|
|
|
|
250 common keyctl __x64_sys_keyctl
|
|
|
|
|
251 common ioprio_set __x64_sys_ioprio_set
|
|
|
|
|
252 common ioprio_get __x64_sys_ioprio_get
|
|
|
|
|
253 common inotify_init __x64_sys_inotify_init
|
|
|
|
|
254 common inotify_add_watch __x64_sys_inotify_add_watch
|
|
|
|
|
255 common inotify_rm_watch __x64_sys_inotify_rm_watch
|
|
|
|
|
256 common migrate_pages __x64_sys_migrate_pages
|
|
|
|
|
257 common openat __x64_sys_openat
|
|
|
|
|
258 common mkdirat __x64_sys_mkdirat
|
|
|
|
|
259 common mknodat __x64_sys_mknodat
|
|
|
|
|
260 common fchownat __x64_sys_fchownat
|
|
|
|
|
261 common futimesat __x64_sys_futimesat
|
|
|
|
|
262 common newfstatat __x64_sys_newfstatat
|
|
|
|
|
263 common unlinkat __x64_sys_unlinkat
|
|
|
|
|
264 common renameat __x64_sys_renameat
|
|
|
|
|
265 common linkat __x64_sys_linkat
|
|
|
|
|
266 common symlinkat __x64_sys_symlinkat
|
|
|
|
|
267 common readlinkat __x64_sys_readlinkat
|
|
|
|
|
268 common fchmodat __x64_sys_fchmodat
|
|
|
|
|
269 common faccessat __x64_sys_faccessat
|
|
|
|
|
270 common pselect6 __x64_sys_pselect6
|
|
|
|
|
271 common ppoll __x64_sys_ppoll
|
|
|
|
|
272 common unshare __x64_sys_unshare
|
|
|
|
|
273 64 set_robust_list __x64_sys_set_robust_list
|
|
|
|
|
274 64 get_robust_list __x64_sys_get_robust_list
|
|
|
|
|
275 common splice __x64_sys_splice
|
|
|
|
|
276 common tee __x64_sys_tee
|
|
|
|
|
277 common sync_file_range __x64_sys_sync_file_range
|
|
|
|
|
278 64 vmsplice __x64_sys_vmsplice
|
|
|
|
|
279 64 move_pages __x64_sys_move_pages
|
|
|
|
|
280 common utimensat __x64_sys_utimensat
|
|
|
|
|
281 common epoll_pwait __x64_sys_epoll_pwait
|
|
|
|
|
282 common signalfd __x64_sys_signalfd
|
|
|
|
|
283 common timerfd_create __x64_sys_timerfd_create
|
|
|
|
|
284 common eventfd __x64_sys_eventfd
|
|
|
|
|
285 common fallocate __x64_sys_fallocate
|
|
|
|
|
286 common timerfd_settime __x64_sys_timerfd_settime
|
|
|
|
|
287 common timerfd_gettime __x64_sys_timerfd_gettime
|
|
|
|
|
288 common accept4 __x64_sys_accept4
|
|
|
|
|
289 common signalfd4 __x64_sys_signalfd4
|
|
|
|
|
290 common eventfd2 __x64_sys_eventfd2
|
|
|
|
|
291 common epoll_create1 __x64_sys_epoll_create1
|
|
|
|
|
292 common dup3 __x64_sys_dup3
|
|
|
|
|
293 common pipe2 __x64_sys_pipe2
|
|
|
|
|
294 common inotify_init1 __x64_sys_inotify_init1
|
|
|
|
|
295 64 preadv __x64_sys_preadv
|
|
|
|
|
296 64 pwritev __x64_sys_pwritev
|
|
|
|
|
297 64 rt_tgsigqueueinfo __x64_sys_rt_tgsigqueueinfo
|
|
|
|
|
298 common perf_event_open __x64_sys_perf_event_open
|
|
|
|
|
299 64 recvmmsg __x64_sys_recvmmsg
|
|
|
|
|
300 common fanotify_init __x64_sys_fanotify_init
|
|
|
|
|
301 common fanotify_mark __x64_sys_fanotify_mark
|
|
|
|
|
302 common prlimit64 __x64_sys_prlimit64
|
|
|
|
|
303 common name_to_handle_at __x64_sys_name_to_handle_at
|
|
|
|
|
304 common open_by_handle_at __x64_sys_open_by_handle_at
|
|
|
|
|
305 common clock_adjtime __x64_sys_clock_adjtime
|
|
|
|
|
306 common syncfs __x64_sys_syncfs
|
|
|
|
|
307 64 sendmmsg __x64_sys_sendmmsg
|
|
|
|
|
308 common setns __x64_sys_setns
|
|
|
|
|
309 common getcpu __x64_sys_getcpu
|
|
|
|
|
310 64 process_vm_readv __x64_sys_process_vm_readv
|
|
|
|
|
311 64 process_vm_writev __x64_sys_process_vm_writev
|
|
|
|
|
312 common kcmp __x64_sys_kcmp
|
|
|
|
|
313 common finit_module __x64_sys_finit_module
|
|
|
|
|
314 common sched_setattr __x64_sys_sched_setattr
|
|
|
|
|
315 common sched_getattr __x64_sys_sched_getattr
|
|
|
|
|
316 common renameat2 __x64_sys_renameat2
|
|
|
|
|
317 common seccomp __x64_sys_seccomp
|
|
|
|
|
318 common getrandom __x64_sys_getrandom
|
|
|
|
|
319 common memfd_create __x64_sys_memfd_create
|
|
|
|
|
320 common kexec_file_load __x64_sys_kexec_file_load
|
|
|
|
|
321 common bpf __x64_sys_bpf
|
|
|
|
|
322 64 execveat __x64_sys_execveat/ptregs
|
|
|
|
|
323 common userfaultfd __x64_sys_userfaultfd
|
|
|
|
|
324 common membarrier __x64_sys_membarrier
|
|
|
|
|
325 common mlock2 __x64_sys_mlock2
|
|
|
|
|
326 common copy_file_range __x64_sys_copy_file_range
|
|
|
|
|
327 64 preadv2 __x64_sys_preadv2
|
|
|
|
|
328 64 pwritev2 __x64_sys_pwritev2
|
|
|
|
|
329 common pkey_mprotect __x64_sys_pkey_mprotect
|
|
|
|
|
330 common pkey_alloc __x64_sys_pkey_alloc
|
|
|
|
|
331 common pkey_free __x64_sys_pkey_free
|
|
|
|
|
332 common statx __x64_sys_statx
|
aio: implement io_pgetevents
This is the io_getevents equivalent of ppoll/pselect and allows to
properly mix signals and aio completions (especially with IOCB_CMD_POLL)
and atomically executes the following sequence:
sigset_t origmask;
pthread_sigmask(SIG_SETMASK, &sigmask, &origmask);
ret = io_getevents(ctx, min_nr, nr, events, timeout);
pthread_sigmask(SIG_SETMASK, &origmask, NULL);
Note that unlike many other signal related calls we do not pass a sigmask
size, as that would get us to 7 arguments, which aren't easily supported
by the syscall infrastructure. It seems a lot less painful to just add a
new syscall variant in the unlikely case we're going to increase the
sigset size.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
2018-05-02 17:51:00 +00:00
|
|
|
333 common io_pgetevents __x64_sys_io_pgetevents
|
2018-06-02 12:43:59 +00:00
|
|
|
334 common rseq __x64_sys_rseq
|
2018-12-31 13:38:26 +00:00
|
|
|
# don't use numbers 387 through 423, add new calls after the last
|
|
|
|
|
# 'common' entry
|
signal: add pidfd_send_signal() syscall
The kill() syscall operates on process identifiers (pid). After a process
has exited its pid can be reused by another process. If a caller sends a
signal to a reused pid it will end up signaling the wrong process. This
issue has often surfaced and there has been a push to address this problem [1].
This patch uses file descriptors (fd) from proc/<pid> as stable handles on
struct pid. Even if a pid is recycled the handle will not change. The fd
can be used to send signals to the process it refers to.
Thus, the new syscall pidfd_send_signal() is introduced to solve this
problem. Instead of pids it operates on process fds (pidfd).
/* prototype and argument /*
long pidfd_send_signal(int pidfd, int sig, siginfo_t *info, unsigned int flags);
/* syscall number 424 */
The syscall number was chosen to be 424 to align with Arnd's rework in his
y2038 to minimize merge conflicts (cf. [25]).
In addition to the pidfd and signal argument it takes an additional
siginfo_t and flags argument. If the siginfo_t argument is NULL then
pidfd_send_signal() is equivalent to kill(<positive-pid>, <signal>). If it
is not NULL pidfd_send_signal() is equivalent to rt_sigqueueinfo().
The flags argument is added to allow for future extensions of this syscall.
It currently needs to be passed as 0. Failing to do so will cause EINVAL.
/* pidfd_send_signal() replaces multiple pid-based syscalls */
The pidfd_send_signal() syscall currently takes on the job of
rt_sigqueueinfo(2) and parts of the functionality of kill(2), Namely, when a
positive pid is passed to kill(2). It will however be possible to also
replace tgkill(2) and rt_tgsigqueueinfo(2) if this syscall is extended.
/* sending signals to threads (tid) and process groups (pgid) */
Specifically, the pidfd_send_signal() syscall does currently not operate on
process groups or threads. This is left for future extensions.
In order to extend the syscall to allow sending signal to threads and
process groups appropriately named flags (e.g. PIDFD_TYPE_PGID, and
PIDFD_TYPE_TID) should be added. This implies that the flags argument will
determine what is signaled and not the file descriptor itself. Put in other
words, grouping in this api is a property of the flags argument not a
property of the file descriptor (cf. [13]). Clarification for this has been
requested by Eric (cf. [19]).
When appropriate extensions through the flags argument are added then
pidfd_send_signal() can additionally replace the part of kill(2) which
operates on process groups as well as the tgkill(2) and
rt_tgsigqueueinfo(2) syscalls.
How such an extension could be implemented has been very roughly sketched
in [14], [15], and [16]. However, this should not be taken as a commitment
to a particular implementation. There might be better ways to do it.
Right now this is intentionally left out to keep this patchset as simple as
possible (cf. [4]).
/* naming */
The syscall had various names throughout iterations of this patchset:
- procfd_signal()
- procfd_send_signal()
- taskfd_send_signal()
In the last round of reviews it was pointed out that given that if the
flags argument decides the scope of the signal instead of different types
of fds it might make sense to either settle for "procfd_" or "pidfd_" as
prefix. The community was willing to accept either (cf. [17] and [18]).
Given that one developer expressed strong preference for the "pidfd_"
prefix (cf. [13]) and with other developers less opinionated about the name
we should settle for "pidfd_" to avoid further bikeshedding.
The "_send_signal" suffix was chosen to reflect the fact that the syscall
takes on the job of multiple syscalls. It is therefore intentional that the
name is not reminiscent of neither kill(2) nor rt_sigqueueinfo(2). Not the
fomer because it might imply that pidfd_send_signal() is a replacement for
kill(2), and not the latter because it is a hassle to remember the correct
spelling - especially for non-native speakers - and because it is not
descriptive enough of what the syscall actually does. The name
"pidfd_send_signal" makes it very clear that its job is to send signals.
/* zombies */
Zombies can be signaled just as any other process. No special error will be
reported since a zombie state is an unreliable state (cf. [3]). However,
this can be added as an extension through the @flags argument if the need
ever arises.
/* cross-namespace signals */
The patch currently enforces that the signaler and signalee either are in
the same pid namespace or that the signaler's pid namespace is an ancestor
of the signalee's pid namespace. This is done for the sake of simplicity
and because it is unclear to what values certain members of struct
siginfo_t would need to be set to (cf. [5], [6]).
/* compat syscalls */
It became clear that we would like to avoid adding compat syscalls
(cf. [7]). The compat syscall handling is now done in kernel/signal.c
itself by adding __copy_siginfo_from_user_generic() which lets us avoid
compat syscalls (cf. [8]). It should be noted that the addition of
__copy_siginfo_from_user_any() is caused by a bug in the original
implementation of rt_sigqueueinfo(2) (cf. 12).
With upcoming rework for syscall handling things might improve
significantly (cf. [11]) and __copy_siginfo_from_user_any() will not gain
any additional callers.
/* testing */
This patch was tested on x64 and x86.
/* userspace usage */
An asciinema recording for the basic functionality can be found under [9].
With this patch a process can be killed via:
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>
static inline int do_pidfd_send_signal(int pidfd, int sig, siginfo_t *info,
unsigned int flags)
{
#ifdef __NR_pidfd_send_signal
return syscall(__NR_pidfd_send_signal, pidfd, sig, info, flags);
#else
return -ENOSYS;
#endif
}
int main(int argc, char *argv[])
{
int fd, ret, saved_errno, sig;
if (argc < 3)
exit(EXIT_FAILURE);
fd = open(argv[1], O_DIRECTORY | O_CLOEXEC);
if (fd < 0) {
printf("%s - Failed to open \"%s\"\n", strerror(errno), argv[1]);
exit(EXIT_FAILURE);
}
sig = atoi(argv[2]);
printf("Sending signal %d to process %s\n", sig, argv[1]);
ret = do_pidfd_send_signal(fd, sig, NULL, 0);
saved_errno = errno;
close(fd);
errno = saved_errno;
if (ret < 0) {
printf("%s - Failed to send signal %d to process %s\n",
strerror(errno), sig, argv[1]);
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
/* Q&A
* Given that it seems the same questions get asked again by people who are
* late to the party it makes sense to add a Q&A section to the commit
* message so it's hopefully easier to avoid duplicate threads.
*
* For the sake of progress please consider these arguments settled unless
* there is a new point that desperately needs to be addressed. Please make
* sure to check the links to the threads in this commit message whether
* this has not already been covered.
*/
Q-01: (Florian Weimer [20], Andrew Morton [21])
What happens when the target process has exited?
A-01: Sending the signal will fail with ESRCH (cf. [22]).
Q-02: (Andrew Morton [21])
Is the task_struct pinned by the fd?
A-02: No. A reference to struct pid is kept. struct pid - as far as I
understand - was created exactly for the reason to not require to
pin struct task_struct (cf. [22]).
Q-03: (Andrew Morton [21])
Does the entire procfs directory remain visible? Just one entry
within it?
A-03: The same thing that happens right now when you hold a file descriptor
to /proc/<pid> open (cf. [22]).
Q-04: (Andrew Morton [21])
Does the pid remain reserved?
A-04: No. This patchset guarantees a stable handle not that pids are not
recycled (cf. [22]).
Q-05: (Andrew Morton [21])
Do attempts to signal that fd return errors?
A-05: See {Q,A}-01.
Q-06: (Andrew Morton [22])
Is there a cleaner way of obtaining the fd? Another syscall perhaps.
A-06: Userspace can already trivially retrieve file descriptors from procfs
so this is something that we will need to support anyway. Hence,
there's no immediate need to add another syscalls just to make
pidfd_send_signal() not dependent on the presence of procfs. However,
adding a syscalls to get such file descriptors is planned for a
future patchset (cf. [22]).
Q-07: (Andrew Morton [21] and others)
This fd-for-a-process sounds like a handy thing and people may well
think up other uses for it in the future, probably unrelated to
signals. Are the code and the interface designed to permit such
future applications?
A-07: Yes (cf. [22]).
Q-08: (Andrew Morton [21] and others)
Now I think about it, why a new syscall? This thing is looking
rather like an ioctl?
A-08: This has been extensively discussed. It was agreed that a syscall is
preferred for a variety or reasons. Here are just a few taken from
prior threads. Syscalls are safer than ioctl()s especially when
signaling to fds. Processes are a core kernel concept so a syscall
seems more appropriate. The layout of the syscall with its four
arguments would require the addition of a custom struct for the
ioctl() thereby causing at least the same amount or even more
complexity for userspace than a simple syscall. The new syscall will
replace multiple other pid-based syscalls (see description above).
The file-descriptors-for-processes concept introduced with this
syscall will be extended with other syscalls in the future. See also
[22], [23] and various other threads already linked in here.
Q-09: (Florian Weimer [24])
What happens if you use the new interface with an O_PATH descriptor?
A-09:
pidfds opened as O_PATH fds cannot be used to send signals to a
process (cf. [2]). Signaling processes through pidfds is the
equivalent of writing to a file. Thus, this is not an operation that
operates "purely at the file descriptor level" as required by the
open(2) manpage. See also [4].
/* References */
[1]: https://lore.kernel.org/lkml/20181029221037.87724-1-dancol@google.com/
[2]: https://lore.kernel.org/lkml/874lbtjvtd.fsf@oldenburg2.str.redhat.com/
[3]: https://lore.kernel.org/lkml/20181204132604.aspfupwjgjx6fhva@brauner.io/
[4]: https://lore.kernel.org/lkml/20181203180224.fkvw4kajtbvru2ku@brauner.io/
[5]: https://lore.kernel.org/lkml/20181121213946.GA10795@mail.hallyn.com/
[6]: https://lore.kernel.org/lkml/20181120103111.etlqp7zop34v6nv4@brauner.io/
[7]: https://lore.kernel.org/lkml/36323361-90BD-41AF-AB5B-EE0D7BA02C21@amacapital.net/
[8]: https://lore.kernel.org/lkml/87tvjxp8pc.fsf@xmission.com/
[9]: https://asciinema.org/a/IQjuCHew6bnq1cr78yuMv16cy
[11]: https://lore.kernel.org/lkml/F53D6D38-3521-4C20-9034-5AF447DF62FF@amacapital.net/
[12]: https://lore.kernel.org/lkml/87zhtjn8ck.fsf@xmission.com/
[13]: https://lore.kernel.org/lkml/871s6u9z6u.fsf@xmission.com/
[14]: https://lore.kernel.org/lkml/20181206231742.xxi4ghn24z4h2qki@brauner.io/
[15]: https://lore.kernel.org/lkml/20181207003124.GA11160@mail.hallyn.com/
[16]: https://lore.kernel.org/lkml/20181207015423.4miorx43l3qhppfz@brauner.io/
[17]: https://lore.kernel.org/lkml/CAGXu5jL8PciZAXvOvCeCU3wKUEB_dU-O3q0tDw4uB_ojMvDEew@mail.gmail.com/
[18]: https://lore.kernel.org/lkml/20181206222746.GB9224@mail.hallyn.com/
[19]: https://lore.kernel.org/lkml/20181208054059.19813-1-christian@brauner.io/
[20]: https://lore.kernel.org/lkml/8736rebl9s.fsf@oldenburg.str.redhat.com/
[21]: https://lore.kernel.org/lkml/20181228152012.dbf0508c2508138efc5f2bbe@linux-foundation.org/
[22]: https://lore.kernel.org/lkml/20181228233725.722tdfgijxcssg76@brauner.io/
[23]: https://lwn.net/Articles/773459/
[24]: https://lore.kernel.org/lkml/8736rebl9s.fsf@oldenburg.str.redhat.com/
[25]: https://lore.kernel.org/lkml/CAK8P3a0ej9NcJM8wXNPbcGUyOUZYX+VLoDFdbenW3s3114oQZw@mail.gmail.com/
Cc: "Eric W. Biederman" <ebiederm@xmission.com>
Cc: Jann Horn <jannh@google.com>
Cc: Andy Lutomirsky <luto@kernel.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Florian Weimer <fweimer@redhat.com>
Signed-off-by: Christian Brauner <christian@brauner.io>
Reviewed-by: Tycho Andersen <tycho@tycho.ws>
Reviewed-by: Kees Cook <keescook@chromium.org>
Reviewed-by: David Howells <dhowells@redhat.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Acked-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: Serge Hallyn <serge@hallyn.com>
Acked-by: Aleksa Sarai <cyphar@cyphar.com>
2018-11-18 23:51:56 +00:00
|
|
|
424 common pidfd_send_signal __x64_sys_pidfd_send_signal
|
Add io_uring IO interface
The submission queue (SQ) and completion queue (CQ) rings are shared
between the application and the kernel. This eliminates the need to
copy data back and forth to submit and complete IO.
IO submissions use the io_uring_sqe data structure, and completions
are generated in the form of io_uring_cqe data structures. The SQ
ring is an index into the io_uring_sqe array, which makes it possible
to submit a batch of IOs without them being contiguous in the ring.
The CQ ring is always contiguous, as completion events are inherently
unordered, and hence any io_uring_cqe entry can point back to an
arbitrary submission.
Two new system calls are added for this:
io_uring_setup(entries, params)
Sets up an io_uring instance for doing async IO. On success,
returns a file descriptor that the application can mmap to
gain access to the SQ ring, CQ ring, and io_uring_sqes.
io_uring_enter(fd, to_submit, min_complete, flags, sigset, sigsetsize)
Initiates IO against the rings mapped to this fd, or waits for
them to complete, or both. The behavior is controlled by the
parameters passed in. If 'to_submit' is non-zero, then we'll
try and submit new IO. If IORING_ENTER_GETEVENTS is set, the
kernel will wait for 'min_complete' events, if they aren't
already available. It's valid to set IORING_ENTER_GETEVENTS
and 'min_complete' == 0 at the same time, this allows the
kernel to return already completed events without waiting
for them. This is useful only for polling, as for IRQ
driven IO, the application can just check the CQ ring
without entering the kernel.
With this setup, it's possible to do async IO with a single system
call. Future developments will enable polled IO with this interface,
and polled submission as well. The latter will enable an application
to do IO without doing ANY system calls at all.
For IRQ driven IO, an application only needs to enter the kernel for
completions if it wants to wait for them to occur.
Each io_uring is backed by a workqueue, to support buffered async IO
as well. We will only punt to an async context if the command would
need to wait for IO on the device side. Any data that can be accessed
directly in the page cache is done inline. This avoids the slowness
issue of usual threadpools, since cached data is accessed as quickly
as a sync interface.
Sample application: http://git.kernel.dk/cgit/fio/plain/t/io_uring.c
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2019-01-07 17:46:33 +00:00
|
|
|
425 common io_uring_setup __x64_sys_io_uring_setup
|
|
|
|
|
426 common io_uring_enter __x64_sys_io_uring_enter
|
io_uring: add support for pre-mapped user IO buffers
If we have fixed user buffers, we can map them into the kernel when we
setup the io_uring. That avoids the need to do get_user_pages() for
each and every IO.
To utilize this feature, the application must call io_uring_register()
after having setup an io_uring instance, passing in
IORING_REGISTER_BUFFERS as the opcode. The argument must be a pointer to
an iovec array, and the nr_args should contain how many iovecs the
application wishes to map.
If successful, these buffers are now mapped into the kernel, eligible
for IO. To use these fixed buffers, the application must use the
IORING_OP_READ_FIXED and IORING_OP_WRITE_FIXED opcodes, and then
set sqe->index to the desired buffer index. sqe->addr..sqe->addr+seq->len
must point to somewhere inside the indexed buffer.
The application may register buffers throughout the lifetime of the
io_uring instance. It can call io_uring_register() with
IORING_UNREGISTER_BUFFERS as the opcode to unregister the current set of
buffers, and then register a new set. The application need not
unregister buffers explicitly before shutting down the io_uring
instance.
It's perfectly valid to setup a larger buffer, and then sometimes only
use parts of it for an IO. As long as the range is within the originally
mapped region, it will work just fine.
For now, buffers must not be file backed. If file backed buffers are
passed in, the registration will fail with -1/EOPNOTSUPP. This
restriction may be relaxed in the future.
RLIMIT_MEMLOCK is used to check how much memory we can pin. A somewhat
arbitrary 1G per buffer size is also imposed.
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2019-01-09 16:16:05 +00:00
|
|
|
427 common io_uring_register __x64_sys_io_uring_register
|
2019-05-16 11:52:27 +00:00
|
|
|
428 common open_tree __x64_sys_open_tree
|
|
|
|
|
429 common move_mount __x64_sys_move_mount
|
|
|
|
|
430 common fsopen __x64_sys_fsopen
|
|
|
|
|
431 common fsconfig __x64_sys_fsconfig
|
|
|
|
|
432 common fsmount __x64_sys_fsmount
|
|
|
|
|
433 common fspick __x64_sys_fspick
|
2019-05-24 10:44:59 +00:00
|
|
|
434 common pidfd_open __x64_sys_pidfd_open
|
2019-07-11 17:09:44 +00:00
|
|
|
435 common clone3 __x64_sys_clone3/ptregs
|
open: introduce openat2(2) syscall
/* Background. */
For a very long time, extending openat(2) with new features has been
incredibly frustrating. This stems from the fact that openat(2) is
possibly the most famous counter-example to the mantra "don't silently
accept garbage from userspace" -- it doesn't check whether unknown flags
are present[1].
This means that (generally) the addition of new flags to openat(2) has
been fraught with backwards-compatibility issues (O_TMPFILE has to be
defined as __O_TMPFILE|O_DIRECTORY|[O_RDWR or O_WRONLY] to ensure old
kernels gave errors, since it's insecure to silently ignore the
flag[2]). All new security-related flags therefore have a tough road to
being added to openat(2).
Userspace also has a hard time figuring out whether a particular flag is
supported on a particular kernel. While it is now possible with
contemporary kernels (thanks to [3]), older kernels will expose unknown
flag bits through fcntl(F_GETFL). Giving a clear -EINVAL during
openat(2) time matches modern syscall designs and is far more
fool-proof.
In addition, the newly-added path resolution restriction LOOKUP flags
(which we would like to expose to user-space) don't feel related to the
pre-existing O_* flag set -- they affect all components of path lookup.
We'd therefore like to add a new flag argument.
Adding a new syscall allows us to finally fix the flag-ignoring problem,
and we can make it extensible enough so that we will hopefully never
need an openat3(2).
/* Syscall Prototype. */
/*
* open_how is an extensible structure (similar in interface to
* clone3(2) or sched_setattr(2)). The size parameter must be set to
* sizeof(struct open_how), to allow for future extensions. All future
* extensions will be appended to open_how, with their zero value
* acting as a no-op default.
*/
struct open_how { /* ... */ };
int openat2(int dfd, const char *pathname,
struct open_how *how, size_t size);
/* Description. */
The initial version of 'struct open_how' contains the following fields:
flags
Used to specify openat(2)-style flags. However, any unknown flag
bits or otherwise incorrect flag combinations (like O_PATH|O_RDWR)
will result in -EINVAL. In addition, this field is 64-bits wide to
allow for more O_ flags than currently permitted with openat(2).
mode
The file mode for O_CREAT or O_TMPFILE.
Must be set to zero if flags does not contain O_CREAT or O_TMPFILE.
resolve
Restrict path resolution (in contrast to O_* flags they affect all
path components). The current set of flags are as follows (at the
moment, all of the RESOLVE_ flags are implemented as just passing
the corresponding LOOKUP_ flag).
RESOLVE_NO_XDEV => LOOKUP_NO_XDEV
RESOLVE_NO_SYMLINKS => LOOKUP_NO_SYMLINKS
RESOLVE_NO_MAGICLINKS => LOOKUP_NO_MAGICLINKS
RESOLVE_BENEATH => LOOKUP_BENEATH
RESOLVE_IN_ROOT => LOOKUP_IN_ROOT
open_how does not contain an embedded size field, because it is of
little benefit (userspace can figure out the kernel open_how size at
runtime fairly easily without it). It also only contains u64s (even
though ->mode arguably should be a u16) to avoid having padding fields
which are never used in the future.
Note that as a result of the new how->flags handling, O_PATH|O_TMPFILE
is no longer permitted for openat(2). As far as I can tell, this has
always been a bug and appears to not be used by userspace (and I've not
seen any problems on my machines by disallowing it). If it turns out
this breaks something, we can special-case it and only permit it for
openat(2) but not openat2(2).
After input from Florian Weimer, the new open_how and flag definitions
are inside a separate header from uapi/linux/fcntl.h, to avoid problems
that glibc has with importing that header.
/* Testing. */
In a follow-up patch there are over 200 selftests which ensure that this
syscall has the correct semantics and will correctly handle several
attack scenarios.
In addition, I've written a userspace library[4] which provides
convenient wrappers around openat2(RESOLVE_IN_ROOT) (this is necessary
because no other syscalls support RESOLVE_IN_ROOT, and thus lots of care
must be taken when using RESOLVE_IN_ROOT'd file descriptors with other
syscalls). During the development of this patch, I've run numerous
verification tests using libpathrs (showing that the API is reasonably
usable by userspace).
/* Future Work. */
Additional RESOLVE_ flags have been suggested during the review period.
These can be easily implemented separately (such as blocking auto-mount
during resolution).
Furthermore, there are some other proposed changes to the openat(2)
interface (the most obvious example is magic-link hardening[5]) which
would be a good opportunity to add a way for userspace to restrict how
O_PATH file descriptors can be re-opened.
Another possible avenue of future work would be some kind of
CHECK_FIELDS[6] flag which causes the kernel to indicate to userspace
which openat2(2) flags and fields are supported by the current kernel
(to avoid userspace having to go through several guesses to figure it
out).
[1]: https://lwn.net/Articles/588444/
[2]: https://lore.kernel.org/lkml/CA+55aFyyxJL1LyXZeBsf2ypriraj5ut1XkNDsunRBqgVjZU_6Q@mail.gmail.com
[3]: commit 629e014bb834 ("fs: completely ignore unknown open flags")
[4]: https://sourceware.org/bugzilla/show_bug.cgi?id=17523
[5]: https://lore.kernel.org/lkml/20190930183316.10190-2-cyphar@cyphar.com/
[6]: https://youtu.be/ggD-eb3yPVs
Suggested-by: Christian Brauner <christian.brauner@ubuntu.com>
Signed-off-by: Aleksa Sarai <cyphar@cyphar.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2020-01-18 12:07:59 +00:00
|
|
|
437 common openat2 __x64_sys_openat2
|
2020-01-07 17:59:26 +00:00
|
|
|
438 common pidfd_getfd __x64_sys_pidfd_getfd
|
2012-05-31 23:26:44 +00:00
|
|
|
|
2012-02-14 22:18:50 +00:00
|
|
|
#
|
|
|
|
|
# x32-specific system call numbers start at 512 to avoid cache impact
|
syscalls/core, syscalls/x86: Clean up compat syscall stub naming convention
Tidy the naming convention for compat syscall subs. Hints which describe
the purpose of the stub go in front and receive a double underscore to
denote that they are generated on-the-fly by the COMPAT_SYSCALL_DEFINEx()
macro.
For the generic case, this means:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
T __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T compat_sys_waitid # alias to __se_compat_sys_waitid()
# (taking parameters as declared), to
# be included in syscall table
For x86, the naming is as follows:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
t __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T __ia32_compat_sys_waitid # IA32_EMULATION 32-bit-ptregs -> C stub,
# calls __se_compat_sys_waitid(); to be
# included in syscall table
T __x32_compat_sys_waitid # x32 64-bit-ptregs -> C stub, calls
# __se_compat_sys_waitid(); to be included
# in syscall table
If only one of IA32_EMULATION and x32 is enabled, __se_compat_sys_waitid()
may be inlined into the stub __{ia32,x32}_compat_sys_waitid().
Suggested-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: Josh Poimboeuf <jpoimboe@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20180409105145.5364-3-linux@dominikbrodowski.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2018-04-09 10:51:43 +00:00
|
|
|
# for native 64-bit operation. The __x32_compat_sys stubs are created
|
syscalls/x86: Use 'struct pt_regs' based syscall calling for IA32_EMULATION and x32
Extend ARCH_HAS_SYSCALL_WRAPPER for i386 emulation and for x32 on 64-bit
x86.
For x32, all we need to do is to create an additional stub for each
compat syscall which decodes the parameters in x86-64 ordering, e.g.:
asmlinkage long __compat_sys_x32_xyzzy(struct pt_regs *regs)
{
return c_SyS_xyzzy(regs->di, regs->si, regs->dx);
}
For i386 emulation, we need to teach compat_sys_*() to take struct
pt_regs as its only argument, e.g.:
asmlinkage long __compat_sys_ia32_xyzzy(struct pt_regs *regs)
{
return c_SyS_xyzzy(regs->bx, regs->cx, regs->dx);
}
In addition, we need to create additional stubs for common syscalls
(that is, for syscalls which have the same parameters on 32-bit and
64-bit), e.g.:
asmlinkage long __sys_ia32_xyzzy(struct pt_regs *regs)
{
return c_sys_xyzzy(regs->bx, regs->cx, regs->dx);
}
This approach avoids leaking random user-provided register content down
the call chain.
This patch is based on an original proof-of-concept
| From: Linus Torvalds <torvalds@linux-foundation.org>
| Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
and was split up and heavily modified by me, in particular to base it on
ARCH_HAS_SYSCALL_WRAPPER.
Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Josh Poimboeuf <jpoimboe@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20180405095307.3730-6-linux@dominikbrodowski.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2018-04-05 09:53:04 +00:00
|
|
|
# on-the-fly for compat_sys_*() compatibility system calls if X86_X32
|
|
|
|
|
# is defined.
|
2012-02-14 22:18:50 +00:00
|
|
|
#
|
syscalls/core, syscalls/x86: Clean up compat syscall stub naming convention
Tidy the naming convention for compat syscall subs. Hints which describe
the purpose of the stub go in front and receive a double underscore to
denote that they are generated on-the-fly by the COMPAT_SYSCALL_DEFINEx()
macro.
For the generic case, this means:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
T __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T compat_sys_waitid # alias to __se_compat_sys_waitid()
# (taking parameters as declared), to
# be included in syscall table
For x86, the naming is as follows:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
t __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T __ia32_compat_sys_waitid # IA32_EMULATION 32-bit-ptregs -> C stub,
# calls __se_compat_sys_waitid(); to be
# included in syscall table
T __x32_compat_sys_waitid # x32 64-bit-ptregs -> C stub, calls
# __se_compat_sys_waitid(); to be included
# in syscall table
If only one of IA32_EMULATION and x32 is enabled, __se_compat_sys_waitid()
may be inlined into the stub __{ia32,x32}_compat_sys_waitid().
Suggested-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: Josh Poimboeuf <jpoimboe@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20180409105145.5364-3-linux@dominikbrodowski.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2018-04-09 10:51:43 +00:00
|
|
|
512 x32 rt_sigaction __x32_compat_sys_rt_sigaction
|
2016-01-28 23:11:26 +00:00
|
|
|
513 x32 rt_sigreturn sys32_x32_rt_sigreturn
|
syscalls/core, syscalls/x86: Clean up compat syscall stub naming convention
Tidy the naming convention for compat syscall subs. Hints which describe
the purpose of the stub go in front and receive a double underscore to
denote that they are generated on-the-fly by the COMPAT_SYSCALL_DEFINEx()
macro.
For the generic case, this means:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
T __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T compat_sys_waitid # alias to __se_compat_sys_waitid()
# (taking parameters as declared), to
# be included in syscall table
For x86, the naming is as follows:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
t __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T __ia32_compat_sys_waitid # IA32_EMULATION 32-bit-ptregs -> C stub,
# calls __se_compat_sys_waitid(); to be
# included in syscall table
T __x32_compat_sys_waitid # x32 64-bit-ptregs -> C stub, calls
# __se_compat_sys_waitid(); to be included
# in syscall table
If only one of IA32_EMULATION and x32 is enabled, __se_compat_sys_waitid()
may be inlined into the stub __{ia32,x32}_compat_sys_waitid().
Suggested-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: Josh Poimboeuf <jpoimboe@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20180409105145.5364-3-linux@dominikbrodowski.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2018-04-09 10:51:43 +00:00
|
|
|
514 x32 ioctl __x32_compat_sys_ioctl
|
|
|
|
|
515 x32 readv __x32_compat_sys_readv
|
|
|
|
|
516 x32 writev __x32_compat_sys_writev
|
|
|
|
|
517 x32 recvfrom __x32_compat_sys_recvfrom
|
|
|
|
|
518 x32 sendmsg __x32_compat_sys_sendmsg
|
|
|
|
|
519 x32 recvmsg __x32_compat_sys_recvmsg
|
|
|
|
|
520 x32 execve __x32_compat_sys_execve/ptregs
|
|
|
|
|
521 x32 ptrace __x32_compat_sys_ptrace
|
|
|
|
|
522 x32 rt_sigpending __x32_compat_sys_rt_sigpending
|
2019-01-11 15:14:21 +00:00
|
|
|
523 x32 rt_sigtimedwait __x32_compat_sys_rt_sigtimedwait_time64
|
syscalls/core, syscalls/x86: Clean up compat syscall stub naming convention
Tidy the naming convention for compat syscall subs. Hints which describe
the purpose of the stub go in front and receive a double underscore to
denote that they are generated on-the-fly by the COMPAT_SYSCALL_DEFINEx()
macro.
For the generic case, this means:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
T __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T compat_sys_waitid # alias to __se_compat_sys_waitid()
# (taking parameters as declared), to
# be included in syscall table
For x86, the naming is as follows:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
t __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T __ia32_compat_sys_waitid # IA32_EMULATION 32-bit-ptregs -> C stub,
# calls __se_compat_sys_waitid(); to be
# included in syscall table
T __x32_compat_sys_waitid # x32 64-bit-ptregs -> C stub, calls
# __se_compat_sys_waitid(); to be included
# in syscall table
If only one of IA32_EMULATION and x32 is enabled, __se_compat_sys_waitid()
may be inlined into the stub __{ia32,x32}_compat_sys_waitid().
Suggested-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: Josh Poimboeuf <jpoimboe@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20180409105145.5364-3-linux@dominikbrodowski.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2018-04-09 10:51:43 +00:00
|
|
|
524 x32 rt_sigqueueinfo __x32_compat_sys_rt_sigqueueinfo
|
|
|
|
|
525 x32 sigaltstack __x32_compat_sys_sigaltstack
|
|
|
|
|
526 x32 timer_create __x32_compat_sys_timer_create
|
|
|
|
|
527 x32 mq_notify __x32_compat_sys_mq_notify
|
|
|
|
|
528 x32 kexec_load __x32_compat_sys_kexec_load
|
|
|
|
|
529 x32 waitid __x32_compat_sys_waitid
|
|
|
|
|
530 x32 set_robust_list __x32_compat_sys_set_robust_list
|
|
|
|
|
531 x32 get_robust_list __x32_compat_sys_get_robust_list
|
|
|
|
|
532 x32 vmsplice __x32_compat_sys_vmsplice
|
|
|
|
|
533 x32 move_pages __x32_compat_sys_move_pages
|
|
|
|
|
534 x32 preadv __x32_compat_sys_preadv64
|
|
|
|
|
535 x32 pwritev __x32_compat_sys_pwritev64
|
|
|
|
|
536 x32 rt_tgsigqueueinfo __x32_compat_sys_rt_tgsigqueueinfo
|
2019-01-11 15:14:21 +00:00
|
|
|
537 x32 recvmmsg __x32_compat_sys_recvmmsg_time64
|
syscalls/core, syscalls/x86: Clean up compat syscall stub naming convention
Tidy the naming convention for compat syscall subs. Hints which describe
the purpose of the stub go in front and receive a double underscore to
denote that they are generated on-the-fly by the COMPAT_SYSCALL_DEFINEx()
macro.
For the generic case, this means:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
T __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T compat_sys_waitid # alias to __se_compat_sys_waitid()
# (taking parameters as declared), to
# be included in syscall table
For x86, the naming is as follows:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
t __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T __ia32_compat_sys_waitid # IA32_EMULATION 32-bit-ptregs -> C stub,
# calls __se_compat_sys_waitid(); to be
# included in syscall table
T __x32_compat_sys_waitid # x32 64-bit-ptregs -> C stub, calls
# __se_compat_sys_waitid(); to be included
# in syscall table
If only one of IA32_EMULATION and x32 is enabled, __se_compat_sys_waitid()
may be inlined into the stub __{ia32,x32}_compat_sys_waitid().
Suggested-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: Josh Poimboeuf <jpoimboe@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20180409105145.5364-3-linux@dominikbrodowski.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2018-04-09 10:51:43 +00:00
|
|
|
538 x32 sendmmsg __x32_compat_sys_sendmmsg
|
|
|
|
|
539 x32 process_vm_readv __x32_compat_sys_process_vm_readv
|
|
|
|
|
540 x32 process_vm_writev __x32_compat_sys_process_vm_writev
|
|
|
|
|
541 x32 setsockopt __x32_compat_sys_setsockopt
|
|
|
|
|
542 x32 getsockopt __x32_compat_sys_getsockopt
|
|
|
|
|
543 x32 io_setup __x32_compat_sys_io_setup
|
|
|
|
|
544 x32 io_submit __x32_compat_sys_io_submit
|
|
|
|
|
545 x32 execveat __x32_compat_sys_execveat/ptregs
|
|
|
|
|
546 x32 preadv2 __x32_compat_sys_preadv64v2
|
|
|
|
|
547 x32 pwritev2 __x32_compat_sys_pwritev64v2
|