1 /* $NetBSD: linux32_sched.c,v 1.10 2026/09/20 13:43:51 riastradh Exp $ */ 2 3 /*- 4 * Copyright (c) 2006 Emmanuel Dreyfus, all rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed by Emmanuel Dreyfus 17 * 4. The name of the author may not be used to endorse or promote 18 * products derived from this software without specific prior written 19 * permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE THE AUTHOR AND CONTRIBUTORS ``AS IS'' 22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 23 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 24 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS 25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 * POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <sys/cdefs.h> 35 36 __KERNEL_RCSID(0, "$NetBSD: linux32_sched.c,v 1.10 2026/09/20 13:43:51 riastradh Exp $"); 37 38 #include <sys/types.h> 39 #include <sys/param.h> 40 #include <sys/fstypes.h> 41 #include <sys/signal.h> 42 #include <sys/dirent.h> 43 #include <sys/kernel.h> 44 #include <sys/fcntl.h> 45 #include <sys/select.h> 46 #include <sys/proc.h> 47 #include <sys/ucred.h> 48 #include <sys/swap.h> 49 50 #include <machine/types.h> 51 52 #include <sys/syscallargs.h> 53 54 #include <compat/netbsd32/netbsd32.h> 55 #include <compat/netbsd32/netbsd32_conv.h> 56 #include <compat/netbsd32/netbsd32_syscallargs.h> 57 58 #include <compat/linux/common/linux_types.h> 59 #include <compat/linux/common/linux_signal.h> 60 #include <compat/linux/common/linux_machdep.h> 61 #include <compat/linux/common/linux_misc.h> 62 #include <compat/linux/common/linux_sched.h> 63 #include <compat/linux/common/linux_ipc.h> 64 #include <compat/linux/common/linux_sem.h> 65 #include <compat/linux/linux_syscallargs.h> 66 67 #include <compat/linux32/common/linux32_types.h> 68 #include <compat/linux32/common/linux32_signal.h> 69 #include <compat/linux32/common/linux32_machdep.h> 70 #include <compat/linux32/common/linux32_sysctl.h> 71 #include <compat/linux32/common/linux32_socketcall.h> 72 #include <compat/linux32/linux32_syscallargs.h> 73 74 int 75 linux32_sys_clone(struct lwp *l, const struct linux32_sys_clone_args *uap, register_t *retval) 76 { 77 /* { 78 syscallarg(int) flags; 79 syscallarg(netbsd32_voidp) stack; 80 syscallarg(netbsd32_voidp) parent_tidptr; 81 syscallarg(netbsd32_voidp) tls; 82 syscallarg(netbsd32_voidp) child_tidptr; 83 } */ 84 struct linux_sys_clone_args ua; 85 86 memset(&ua, 0, sizeof(ua)); 87 NETBSD32TO64_UAP(flags); 88 NETBSD32TOP_UAP(stack, void *); 89 NETBSD32TOP_UAP(parent_tidptr, void *); 90 NETBSD32TOP_UAP(tls, void *); 91 NETBSD32TOP_UAP(child_tidptr, void *); 92 return linux_sys_clone(l, &ua, retval); 93 } 94 95 int 96 linux32_sys_sched_getscheduler(struct lwp *l, const struct linux32_sys_sched_getscheduler_args *uap, register_t *retval) 97 { 98 /* { 99 syscallarg(pid_t) pid; 100 } */ 101 struct linux_sys_sched_getscheduler_args ua; 102 103 memset(&ua, 0, sizeof(ua)); 104 NETBSD32TO64_UAP(pid); 105 return linux_sys_sched_getscheduler(l, &ua, retval); 106 } 107 108 int 109 linux32_sys_sched_setscheduler(struct lwp *l, const struct linux32_sys_sched_setscheduler_args *uap, register_t *retval) 110 { 111 /* { 112 syscallarg(int) pid; 113 syscallarg(int) policy; 114 syscallarg(const linux32_sched_paramp_t) sp; 115 } */ 116 struct linux_sys_sched_setscheduler_args ua; 117 118 memset(&ua, 0, sizeof(ua)); 119 NETBSD32TO64_UAP(pid); 120 NETBSD32TO64_UAP(policy); 121 NETBSD32TOP_UAP(sp, const struct linux_sched_param); 122 return linux_sys_sched_setscheduler(l, &ua, retval); 123 } 124 125 int 126 linux32_sys_sched_getparam(struct lwp *l, const struct linux32_sys_sched_getparam_args *uap, register_t *retval) 127 { 128 /* { 129 syscallarg(pid_t) pid; 130 syscallarg(linux32_sched_paramp_t) sp; 131 } */ 132 struct linux_sys_sched_getparam_args ua; 133 134 memset(&ua, 0, sizeof(ua)); 135 NETBSD32TO64_UAP(pid); 136 NETBSD32TOP_UAP(sp, struct linux_sched_param); 137 return linux_sys_sched_getparam(l, &ua, retval); 138 } 139 140 int 141 linux32_sys_sched_setparam(struct lwp *l, const struct linux32_sys_sched_setparam_args *uap, register_t *retval) 142 { 143 /* { 144 syscallarg(pid_t) pid; 145 syscallarg(const linux32_sched_paramp_t) sp; 146 } */ 147 struct linux_sys_sched_setparam_args ua; 148 149 memset(&ua, 0, sizeof(ua)); 150 NETBSD32TO64_UAP(pid); 151 NETBSD32TOP_UAP(sp, const struct linux_sched_param); 152 return linux_sys_sched_setparam(l, &ua, retval); 153 } 154 155 int 156 linux32_sys_exit_group(struct lwp *l, const struct linux32_sys_exit_group_args *uap, register_t *retval) 157 { 158 /* { 159 syscallarg(int) error_code; 160 } */ 161 struct linux_sys_exit_group_args ua; 162 163 memset(&ua, 0, sizeof(ua)); 164 NETBSD32TO64_UAP(error_code); 165 return linux_sys_exit_group(l, &ua, retval); 166 } 167 168 int 169 linux32_sys_exit(struct lwp *l, const struct linux32_sys_exit_args *uap, register_t *retval) 170 { 171 172 /* { 173 syscallarg(int) rval; 174 } */ 175 struct linux_sys_exit_args ua; 176 177 memset(&ua, 0, sizeof(ua)); 178 NETBSD32TO64_UAP(rval); 179 return linux_sys_exit(l, &ua, retval); 180 } 181 182 int 183 linux32_sys_sched_get_priority_max(struct lwp *l, const struct linux32_sys_sched_get_priority_max_args *uap, register_t *retval) 184 { 185 /* { 186 syscallarg(int) policy; 187 } */ 188 189 struct linux_sys_sched_get_priority_max_args ua; 190 191 memset(&ua, 0, sizeof(ua)); 192 NETBSD32TO64_UAP(policy); 193 return linux_sys_sched_get_priority_max(l, &ua, retval); 194 } 195 196 int 197 linux32_sys_sched_get_priority_min(struct lwp *l, const struct linux32_sys_sched_get_priority_min_args *uap, register_t *retval) 198 { 199 /* { 200 syscallarg(int) policy; 201 } */ 202 203 struct linux_sys_sched_get_priority_min_args ua; 204 205 memset(&ua, 0, sizeof(ua)); 206 NETBSD32TO64_UAP(policy); 207 return linux_sys_sched_get_priority_min(l, &ua, retval); 208 } 209 210 211 int 212 linux32_sys_set_tid_address(struct lwp *l, const struct linux32_sys_set_tid_address_args *uap, register_t *retval) 213 { 214 /* { 215 syscallarg(linux32_intp_t) tid; 216 } */ 217 struct linux_sys_set_tid_address_args ua; 218 219 memset(&ua, 0, sizeof(ua)); 220 NETBSD32TOP_UAP(tid, int); 221 return linux_sys_set_tid_address(l, &ua, retval); 222 } 223 224 int 225 linux32_sys_sched_getaffinity(struct lwp *l, const struct linux32_sys_sched_getaffinity_args *uap, register_t *retval) 226 { 227 /* { 228 syscallarg(linux_pid_t) pid; 229 syscallarg(unsigned int) len; 230 syscallarg(linux32_longp_t) mask; 231 } */ 232 struct linux_sys_sched_getaffinity_args ua; 233 234 memset(&ua, 0, sizeof(ua)); 235 NETBSD32TO64_UAP(pid); 236 NETBSD32TO64_UAP(len); 237 NETBSD32TOP_UAP(mask, long); 238 return linux_sys_sched_getaffinity(l, &ua, retval); 239 } 240 241 int 242 linux32_sys_sched_setaffinity(struct lwp *l, const struct linux32_sys_sched_setaffinity_args *uap, register_t *retval) 243 { 244 /* { 245 syscallarg(linux_pid_t) pid; 246 syscallarg(unsigned int) len; 247 syscallarg(linux32_longp_t) mask; 248 } */ 249 struct linux_sys_sched_setaffinity_args ua; 250 251 memset(&ua, 0, sizeof(ua)); 252 NETBSD32TO64_UAP(pid); 253 NETBSD32TO64_UAP(len); 254 NETBSD32TOP_UAP(mask, long); 255 return linux_sys_sched_setaffinity(l, &ua, retval); 256 } 257 258 int 259 linux32_sys_tkill(struct lwp *l, const struct linux32_sys_tkill_args *uap, register_t *retval) 260 { 261 /* { 262 syscallarg(int) tid; 263 syscallarg(int) sig; 264 } */ 265 struct linux_sys_tkill_args ua; 266 267 memset(&ua, 0, sizeof(ua)); 268 NETBSD32TO64_UAP(tid); 269 NETBSD32TO64_UAP(sig); 270 return linux_sys_tkill(l, &ua, retval); 271 } 272 273 int 274 linux32_sys_tgkill(struct lwp *l, const struct linux32_sys_tgkill_args *uap, register_t *retval) 275 { 276 /* { 277 syscallarg(int) tgid; 278 syscallarg(int) tid; 279 syscallarg(int) sig; 280 } */ 281 struct linux_sys_tgkill_args ua; 282 283 memset(&ua, 0, sizeof(ua)); 284 NETBSD32TO64_UAP(tgid); 285 NETBSD32TO64_UAP(tid); 286 NETBSD32TO64_UAP(sig); 287 return linux_sys_tgkill(l, &ua, retval); 288 } 289
Indexes created Sun Oct 25 00:26:45 UTC 2026