linux32_ipccall.c revision 1.7
1 /* $NetBSD: linux32_ipccall.c,v 1.7 2009/11/18 12:01:25 njoly Exp $ */ 2 3 /* 4 * Copyright (c) 2008 Nicolas Joly 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: linux32_ipccall.c,v 1.7 2009/11/18 12:01:25 njoly Exp $"); 31 32 #if defined(_KERNEL_OPT) 33 #include "opt_sysv.h" 34 #endif 35 36 #include <sys/param.h> 37 #include <sys/vnode.h> 38 #include <sys/msg.h> 39 #include <sys/sem.h> 40 #include <sys/shm.h> 41 42 #include <sys/syscallargs.h> 43 44 #include <compat/netbsd32/netbsd32.h> 45 46 #include <compat/linux/common/linux_types.h> 47 #include <compat/linux32/common/linux32_types.h> 48 #include <compat/linux32/common/linux32_signal.h> 49 #include <compat/linux32/linux32_syscallargs.h> 50 #include <compat/linux32/common/linux32_ipc.h> 51 #include <compat/linux32/common/linux32_sem.h> 52 #include <compat/linux32/common/linux32_shm.h> 53 54 #define LINUX32_IPC_semop 1 55 #define LINUX32_IPC_semget 2 56 #define LINUX32_IPC_semctl 3 57 #define LINUX32_IPC_msgsnd 11 58 #define LINUX32_IPC_msgrcv 12 59 #define LINUX32_IPC_msgget 13 60 #define LINUX32_IPC_msgctl 14 61 #define LINUX32_IPC_shmat 21 62 #define LINUX32_IPC_shmdt 22 63 #define LINUX32_IPC_shmget 23 64 #define LINUX32_IPC_shmctl 24 65 66 #ifdef SYSVSEM 67 static void 68 bsd_to_linux32_semid_ds(struct semid_ds *, struct linux32_semid_ds *); 69 static void 70 bsd_to_linux32_semid64_ds(struct semid_ds *, struct linux32_semid64_ds *); 71 static void 72 linux32_to_bsd_semid_ds(struct linux32_semid_ds *, struct semid_ds *); 73 static void 74 linux32_to_bsd_semid64_ds(struct linux32_semid64_ds *, struct semid_ds *); 75 76 static int 77 linux32_semop(struct lwp *, const struct linux32_sys_ipc_args *, register_t *); 78 static int 79 linux32_semget(struct lwp *, const struct linux32_sys_ipc_args *, register_t *); 80 static int 81 linux32_semctl(struct lwp *, const struct linux32_sys_ipc_args *, register_t *); 82 #endif /* SYSVSEM */ 83 84 #ifdef SYSVSHM 85 static void 86 bsd_to_linux32_shmid_ds(struct shmid_ds *, struct linux32_shmid_ds *); 87 static void 88 linux32_to_bsd_shmid_ds(struct linux32_shmid_ds *, struct shmid_ds *); 89 static void 90 bsd_to_linux32_shmid64_ds(struct shmid_ds *, struct linux32_shmid64_ds *); 91 static void 92 linux32_to_bsd_shmid64_ds(struct linux32_shmid64_ds *, struct shmid_ds *); 93 94 static int 95 linux32_shmat(struct lwp *, const struct linux32_sys_ipc_args *, register_t *); 96 static int 97 linux32_shmdt(struct lwp *, const struct linux32_sys_ipc_args *, register_t *); 98 static int 99 linux32_shmget(struct lwp *, const struct linux32_sys_ipc_args *, register_t *); 100 static int 101 linux32_shmctl(struct lwp *, const struct linux32_sys_ipc_args *, register_t *); 102 #endif /* SYSVSHM */ 103 104 #ifdef SYSVMSG 105 static int linux32_msgsnd(struct lwp *, const struct linux32_sys_ipc_args *, 106 register_t *); 107 static int linux32_msgrcv(struct lwp *, const struct linux32_sys_ipc_args *, 108 register_t *); 109 static int linux32_msgget(struct lwp *, const struct linux32_sys_ipc_args *, 110 register_t *); 111 static int linux32_msgctl(struct lwp *, const struct linux32_sys_ipc_args *, 112 register_t *); 113 #endif 114 115 int 116 linux32_sys_ipc(struct lwp *l, const struct linux32_sys_ipc_args *uap, 117 register_t *retval) 118 { 119 /* { 120 syscallarg(int) what; 121 syscallarg(int) a1; 122 syscallarg(int) a2; 123 syscallarg(int) a3; 124 syscallarg(netbsd32_voidp) ptr; 125 } */ 126 127 switch (SCARG(uap, what)) { 128 #ifdef SYSVSEM 129 case LINUX32_IPC_semop: 130 return linux32_semop(l, uap, retval);; 131 case LINUX32_IPC_semget: 132 return linux32_semget(l, uap, retval); 133 case LINUX32_IPC_semctl: 134 return linux32_semctl(l, uap, retval); 135 #endif /* SYSVSEM */ 136 #ifdef SYSVMSG 137 case LINUX32_IPC_msgsnd: 138 return linux32_msgsnd(l, uap, retval); 139 case LINUX32_IPC_msgrcv: 140 return linux32_msgrcv(l, uap, retval); 141 case LINUX32_IPC_msgget: 142 return linux32_msgget(l, uap, retval); 143 case LINUX32_IPC_msgctl: 144 return linux32_msgctl(l, uap, retval); 145 #endif 146 #ifdef SYSVSHM 147 case LINUX32_IPC_shmat: 148 return linux32_shmat(l, uap, retval); 149 case LINUX32_IPC_shmdt: 150 return linux32_shmdt(l, uap, retval); 151 case LINUX32_IPC_shmget: 152 return linux32_shmget(l, uap, retval); 153 case LINUX32_IPC_shmctl: 154 return linux32_shmctl(l, uap, retval); 155 #endif /* SYSVSHM */ 156 default: 157 return ENOSYS; 158 } 159 160 } 161 162 static void 163 bsd_to_linux32_ipc_perm(struct ipc_perm *bpp, struct linux32_ipc_perm *lpp) 164 { 165 lpp->l_key = bpp->_key; 166 lpp->l_uid = bpp->uid; 167 lpp->l_gid = bpp->gid; 168 lpp->l_cuid = bpp->cuid; 169 lpp->l_cgid = bpp->cgid; 170 lpp->l_mode = bpp->mode; 171 lpp->l_seq = bpp->_seq; 172 } 173 174 static void 175 linux32_to_bsd_ipc_perm(struct linux32_ipc_perm *lpp, struct ipc_perm *bpp) 176 { 177 bpp->_key = lpp->l_key; 178 bpp->uid = lpp->l_uid; 179 bpp->gid = lpp->l_gid; 180 bpp->cuid = lpp->l_cuid; 181 bpp->cgid = lpp->l_cgid; 182 bpp->mode = lpp->l_mode; 183 bpp->_seq = lpp->l_seq; 184 } 185 186 static void 187 bsd_to_linux32_ipc64_perm(struct ipc_perm *bpp, struct linux32_ipc64_perm *lpp) 188 { 189 lpp->l_key = bpp->_key; 190 lpp->l_uid = bpp->uid; 191 lpp->l_gid = bpp->gid; 192 lpp->l_cuid = bpp->cuid; 193 lpp->l_cgid = bpp->cgid; 194 lpp->l_mode = bpp->mode; 195 lpp->l_seq = bpp->_seq; 196 } 197 198 static void 199 linux32_to_bsd_ipc64_perm(struct linux32_ipc64_perm *lpp, struct ipc_perm *bpp) 200 { 201 bpp->_key = lpp->l_key; 202 bpp->uid = lpp->l_uid; 203 bpp->gid = lpp->l_gid; 204 bpp->cuid = lpp->l_cuid; 205 bpp->cgid = lpp->l_cgid; 206 bpp->mode = lpp->l_mode; 207 bpp->_seq = lpp->l_seq; 208 } 209 210 #ifdef SYSVSEM 211 static void 212 bsd_to_linux32_semid_ds(struct semid_ds *bsp, struct linux32_semid_ds *lsp) 213 { 214 bsd_to_linux32_ipc_perm(&bsp->sem_perm, &lsp->l_sem_perm); 215 lsp->l_sem_otime = bsp->sem_otime; 216 lsp->l_sem_ctime = bsp->sem_ctime; 217 lsp->l_sem_nsems = bsp->sem_nsems; 218 NETBSD32PTR32(lsp->l_sem_base, bsp->_sem_base); 219 } 220 221 static void 222 bsd_to_linux32_semid64_ds(struct semid_ds *bsp, struct linux32_semid64_ds *lsp) 223 { 224 bsd_to_linux32_ipc64_perm(&bsp->sem_perm, &lsp->l_sem_perm); 225 lsp->l_sem_otime = bsp->sem_otime; 226 lsp->l_sem_ctime = bsp->sem_ctime; 227 lsp->l_sem_nsems = bsp->sem_nsems; 228 } 229 230 static void 231 linux32_to_bsd_semid_ds(struct linux32_semid_ds *lsp, struct semid_ds *bsp) 232 { 233 linux32_to_bsd_ipc_perm(&lsp->l_sem_perm, &bsp->sem_perm); 234 bsp->sem_otime = lsp->l_sem_otime; 235 bsp->sem_ctime = lsp->l_sem_ctime; 236 bsp->sem_nsems = lsp->l_sem_nsems; 237 bsp->_sem_base = NETBSD32PTR64(lsp->l_sem_base); 238 } 239 240 static void 241 linux32_to_bsd_semid64_ds(struct linux32_semid64_ds *lsp, struct semid_ds *bsp) 242 { 243 linux32_to_bsd_ipc64_perm(&lsp->l_sem_perm, &bsp->sem_perm); 244 bsp->sem_otime = lsp->l_sem_otime; 245 bsp->sem_ctime = lsp->l_sem_ctime; 246 bsp->sem_nsems = lsp->l_sem_nsems; 247 } 248 249 static int 250 linux32_semop(struct lwp *l, const struct linux32_sys_ipc_args *uap, 251 register_t *retval) 252 { 253 struct sys_semop_args ua; 254 255 SCARG(&ua, semid) = SCARG(uap, a1); 256 SCARG(&ua, sops) = SCARG_P32(uap, ptr); 257 SCARG(&ua, nsops) = SCARG(uap, a2); 258 259 return sys_semop(l, &ua, retval); 260 } 261 262 static int 263 linux32_semget(struct lwp *l, const struct linux32_sys_ipc_args *uap, 264 register_t *retval) 265 { 266 struct sys_semget_args ua; 267 268 SCARG(&ua, key) = SCARG(uap, a1); 269 SCARG(&ua, nsems) = SCARG(uap, a2); 270 SCARG(&ua, semflg) = SCARG(uap, a3); 271 272 return sys_semget(l, &ua, retval); 273 } 274 275 static int 276 linux32_semctl(struct lwp *l, const struct linux32_sys_ipc_args *uap, 277 register_t *retval) 278 { 279 int lcmd, cmd, error; 280 struct semid_ds bs; 281 struct linux32_semid_ds ls; 282 struct linux32_semid64_ds ls64; 283 union linux32_semun lsem; 284 union __semun bsem; 285 void *buf = NULL; 286 287 if ((error = copyin(SCARG_P32(uap, ptr), &lsem, sizeof lsem))) 288 return error; 289 290 lcmd = SCARG(uap, a3); 291 292 switch (lcmd & ~LINUX32_IPC_64) { 293 case LINUX32_IPC_RMID: 294 cmd = IPC_RMID; 295 break; 296 case LINUX32_IPC_STAT: 297 cmd = IPC_STAT; 298 buf = &bs; 299 break; 300 case LINUX32_IPC_SET: 301 if (lcmd & LINUX32_IPC_64) { 302 error = copyin(NETBSD32PTR64(lsem.l_buf), &ls64, 303 sizeof ls64); 304 linux32_to_bsd_semid64_ds(&ls64, &bs); 305 } else { 306 error = copyin(NETBSD32PTR64(lsem.l_buf), &ls, 307 sizeof ls); 308 linux32_to_bsd_semid_ds(&ls, &bs); 309 } 310 if (error) 311 return error; 312 cmd = IPC_SET; 313 buf = &bs; 314 break; 315 case LINUX32_GETVAL: 316 cmd = GETVAL; 317 break; 318 case LINUX32_SETVAL: 319 cmd = SETVAL; 320 bsem.val = lsem.l_val; 321 buf = &bsem; 322 break; 323 case LINUX32_GETPID: 324 cmd = GETPID; 325 break; 326 case LINUX32_GETNCNT: 327 cmd = GETNCNT; 328 break; 329 case LINUX32_GETZCNT: 330 cmd = GETZCNT; 331 break; 332 case LINUX32_GETALL: 333 cmd = GETALL; 334 bsem.array = NETBSD32PTR64(lsem.l_array); 335 buf = &bsem; 336 break; 337 case LINUX32_SETALL: 338 cmd = SETALL; 339 bsem.array = NETBSD32PTR64(lsem.l_array); 340 buf = &bsem; 341 break; 342 default: 343 return EINVAL; 344 } 345 346 error = semctl1(l, SCARG(uap, a1), SCARG(uap, a2), cmd, buf, retval); 347 if (error) 348 return error; 349 350 switch (lcmd) { 351 case LINUX32_IPC_STAT: 352 bsd_to_linux32_semid_ds(&bs, &ls); 353 error = copyout(&ls, NETBSD32PTR64(lsem.l_buf), sizeof ls); 354 break; 355 case LINUX32_IPC_STAT|LINUX32_IPC_64: 356 bsd_to_linux32_semid64_ds(&bs, &ls64); 357 error = copyout(&ls64, NETBSD32PTR64(lsem.l_buf), sizeof ls64); 358 break; 359 default: 360 break; 361 } 362 363 return error; 364 } 365 #endif /* SYSVSEM */ 366 367 #ifdef SYSVMSG 368 369 static int 370 linux32_msgsnd(struct lwp *l, const struct linux32_sys_ipc_args *uap, register_t *retval) 371 { 372 struct sys_msgsnd_args bma; 373 374 SCARG(&bma, msqid) = SCARG(uap, a1); 375 SCARG(&bma, msgp) = SCARG_P32(uap, ptr); 376 SCARG(&bma, msgsz) = SCARG(uap, a2); 377 SCARG(&bma, msgflg) = SCARG(uap, a3); 378 379 return sys_msgsnd(l, &bma, retval); 380 } 381 382 /* 383 * This kludge is used for the 6th argument to the msgrcv system 384 * call, to get around the maximum of 5 arguments to a syscall in Linux. 385 */ 386 struct linux32_msgrcv_msgarg { 387 netbsd32_pointer_t msg; 388 int type; 389 }; 390 391 static int 392 linux32_msgrcv(struct lwp *l, const struct linux32_sys_ipc_args *uap, register_t *retval) 393 { 394 struct sys_msgrcv_args bma; 395 struct linux32_msgrcv_msgarg kluge; 396 int error; 397 398 if ((error = copyin(SCARG_P32(uap, ptr), &kluge, sizeof kluge))) 399 return error; 400 401 SCARG(&bma, msqid) = SCARG(uap, a1); 402 SCARG(&bma, msgp) = NETBSD32PTR64(kluge.msg); 403 SCARG(&bma, msgsz) = SCARG(uap, a2); 404 SCARG(&bma, msgtyp) = kluge.type; 405 SCARG(&bma, msgflg) = SCARG(uap, a3); 406 407 return sys_msgrcv(l, &bma, retval); 408 } 409 410 static int 411 linux32_msgget(struct lwp *l, const struct linux32_sys_ipc_args *uap, register_t *retval) 412 { 413 struct sys_msgget_args bma; 414 415 SCARG(&bma, key) = (key_t)(linux32_key_t)SCARG(uap, a1); 416 SCARG(&bma, msgflg) = SCARG(uap, a2); 417 418 return sys_msgget(l, &bma, retval); 419 } 420 421 422 static void 423 linux32_to_bsd_msqid_ds(struct linux32_msqid_ds *lmp, struct msqid_ds *bmp) 424 { 425 426 memset(bmp, 0, sizeof(*bmp)); 427 linux32_to_bsd_ipc_perm(&lmp->l_msg_perm, &bmp->msg_perm); 428 bmp->_msg_first = NETBSD32PTR64(lmp->l_msg_first); 429 bmp->_msg_last = NETBSD32PTR64(lmp->l_msg_last); 430 bmp->_msg_cbytes = lmp->l_msg_cbytes; 431 bmp->msg_qnum = lmp->l_msg_qnum; 432 bmp->msg_qbytes = lmp->l_msg_qbytes; 433 bmp->msg_lspid = lmp->l_msg_lspid; 434 bmp->msg_lrpid = lmp->l_msg_lrpid; 435 bmp->msg_stime = lmp->l_msg_stime; 436 bmp->msg_rtime = lmp->l_msg_rtime; 437 bmp->msg_ctime = lmp->l_msg_ctime; 438 } 439 440 static void 441 linux32_to_bsd_msqid64_ds(struct linux32_msqid64_ds *lmp, struct msqid_ds *bmp) 442 { 443 444 memset(bmp, 0, sizeof(*bmp)); 445 linux32_to_bsd_ipc64_perm(&lmp->l_msg_perm, &bmp->msg_perm); 446 bmp->msg_stime = lmp->l_msg_stime; 447 bmp->msg_rtime = lmp->l_msg_rtime; 448 bmp->msg_ctime = lmp->l_msg_ctime; 449 bmp->_msg_cbytes = lmp->l_msg_cbytes; 450 bmp->msg_qnum = lmp->l_msg_qnum; 451 bmp->msg_qbytes = lmp->l_msg_qbytes; 452 bmp->msg_lspid = lmp->l_msg_lspid; 453 bmp->msg_lrpid = lmp->l_msg_lrpid; 454 } 455 456 static void 457 bsd_to_linux32_msqid_ds(struct msqid_ds *bmp, struct linux32_msqid_ds *lmp) 458 { 459 460 memset(lmp, 0, sizeof(*lmp)); 461 bsd_to_linux32_ipc_perm(&bmp->msg_perm, &lmp->l_msg_perm); 462 NETBSD32PTR32(lmp->l_msg_first, bmp->_msg_first); 463 NETBSD32PTR32(lmp->l_msg_last, bmp->_msg_last); 464 lmp->l_msg_cbytes = bmp->_msg_cbytes; 465 lmp->l_msg_qnum = bmp->msg_qnum; 466 lmp->l_msg_qbytes = bmp->msg_qbytes; 467 lmp->l_msg_lspid = bmp->msg_lspid; 468 lmp->l_msg_lrpid = bmp->msg_lrpid; 469 lmp->l_msg_stime = bmp->msg_stime; 470 lmp->l_msg_rtime = bmp->msg_rtime; 471 lmp->l_msg_ctime = bmp->msg_ctime; 472 } 473 474 static void 475 bsd_to_linux32_msqid64_ds(struct msqid_ds *bmp, struct linux32_msqid64_ds *lmp) 476 { 477 478 memset(lmp, 0, sizeof(*lmp)); 479 bsd_to_linux32_ipc64_perm(&bmp->msg_perm, &lmp->l_msg_perm); 480 lmp->l_msg_stime = bmp->msg_stime; 481 lmp->l_msg_rtime = bmp->msg_rtime; 482 lmp->l_msg_ctime = bmp->msg_ctime; 483 lmp->l_msg_cbytes = bmp->_msg_cbytes; 484 lmp->l_msg_qnum = bmp->msg_qnum; 485 lmp->l_msg_qbytes = bmp->msg_qbytes; 486 lmp->l_msg_lspid = bmp->msg_lspid; 487 lmp->l_msg_lrpid = bmp->msg_lrpid; 488 } 489 490 static int 491 linux32_msgctl(struct lwp *l, const struct linux32_sys_ipc_args *uap, register_t *retval) 492 { 493 struct msqid_ds bm, *bmp = NULL; 494 struct linux32_msqid_ds lm; 495 struct linux32_msqid64_ds lm64; 496 int cmd, lcmd, error; 497 void *data = SCARG_P32(uap, ptr); 498 499 lcmd = SCARG(uap, a2); 500 501 switch (lcmd & ~LINUX32_IPC_64) { 502 case LINUX32_IPC_STAT: 503 cmd = IPC_STAT; 504 bmp = &bm; 505 break; 506 case LINUX32_IPC_SET: 507 if (lcmd & LINUX32_IPC_64) { 508 error = copyin(data, &lm64, sizeof lm64); 509 linux32_to_bsd_msqid64_ds(&lm64, &bm); 510 } else { 511 error = copyin(data, &lm, sizeof lm); 512 linux32_to_bsd_msqid_ds(&lm, &bm); 513 } 514 if (error) 515 return error; 516 cmd = IPC_SET; 517 bmp = &bm; 518 break; 519 case LINUX32_IPC_RMID: 520 cmd = IPC_RMID; 521 break; 522 default: 523 return EINVAL; 524 } 525 526 if ((error = msgctl1(l, SCARG(uap, a1), cmd, bmp))) 527 return error; 528 529 switch (lcmd) { 530 case LINUX32_IPC_STAT: 531 bsd_to_linux32_msqid_ds(&bm, &lm); 532 error = copyout(&lm, data, sizeof lm); 533 break; 534 case LINUX32_IPC_STAT|LINUX32_IPC_64: 535 bsd_to_linux32_msqid64_ds(&bm, &lm64); 536 error = copyout(&lm64, data, sizeof lm64); 537 break; 538 default: 539 break; 540 } 541 542 return error; 543 } 544 #endif /* SYSVMSG */ 545 546 #ifdef SYSVSHM 547 static void 548 bsd_to_linux32_shmid_ds(struct shmid_ds *bsp, struct linux32_shmid_ds *lsp) 549 { 550 bsd_to_linux32_ipc_perm(&bsp->shm_perm, &lsp->l_shm_perm); 551 lsp->l_shm_segsz = bsp->shm_segsz; 552 lsp->l_shm_atime = bsp->shm_atime; 553 lsp->l_shm_dtime = bsp->shm_dtime; 554 lsp->l_shm_ctime = bsp->shm_ctime; 555 lsp->l_shm_cpid = bsp->shm_cpid; 556 lsp->l_shm_lpid = bsp->shm_lpid; 557 lsp->l_shm_nattch = bsp->shm_nattch; 558 NETBSD32PTR32(lsp->l_private2, bsp->_shm_internal); 559 } 560 561 static void 562 linux32_to_bsd_shmid_ds(struct linux32_shmid_ds *lsp, struct shmid_ds *bsp) 563 { 564 linux32_to_bsd_ipc_perm(&lsp->l_shm_perm, &bsp->shm_perm); 565 bsp->shm_segsz = lsp->l_shm_segsz; 566 bsp->shm_atime = lsp->l_shm_atime; 567 bsp->shm_dtime = lsp->l_shm_dtime; 568 bsp->shm_ctime = lsp->l_shm_ctime; 569 bsp->shm_cpid = lsp->l_shm_cpid; 570 bsp->shm_lpid = lsp->l_shm_lpid; 571 bsp->shm_nattch = lsp->l_shm_nattch; 572 bsp->_shm_internal = NETBSD32PTR64(lsp->l_private2); 573 } 574 575 static void 576 bsd_to_linux32_shmid64_ds(struct shmid_ds *bsp, struct linux32_shmid64_ds *lsp) 577 { 578 bsd_to_linux32_ipc64_perm(&bsp->shm_perm, &lsp->l_shm_perm); 579 lsp->l_shm_segsz = bsp->shm_segsz; 580 lsp->l_shm_atime = bsp->shm_atime; 581 lsp->l_shm_dtime = bsp->shm_dtime; 582 lsp->l_shm_ctime = bsp->shm_ctime; 583 lsp->l_shm_cpid = bsp->shm_cpid; 584 lsp->l_shm_lpid = bsp->shm_lpid; 585 lsp->l_shm_nattch = bsp->shm_nattch; 586 lsp->l___unused5 = NETBSD32PTR32I(bsp->_shm_internal); 587 } 588 589 static void 590 linux32_to_bsd_shmid64_ds(struct linux32_shmid64_ds *lsp, struct shmid_ds *bsp) 591 { 592 linux32_to_bsd_ipc64_perm(&lsp->l_shm_perm, &bsp->shm_perm); 593 bsp->shm_segsz = lsp->l_shm_segsz; 594 bsp->shm_atime = lsp->l_shm_atime; 595 bsp->shm_dtime = lsp->l_shm_dtime; 596 bsp->shm_ctime = lsp->l_shm_ctime; 597 bsp->shm_cpid = lsp->l_shm_cpid; 598 bsp->shm_lpid = lsp->l_shm_lpid; 599 bsp->shm_nattch = lsp->l_shm_nattch; 600 bsp->_shm_internal = NETBSD32IPTR64(lsp->l___unused5); 601 } 602 603 static int 604 linux32_shmat(struct lwp *l, const struct linux32_sys_ipc_args *uap, 605 register_t *retval) 606 { 607 struct sys_shmat_args ua; 608 netbsd32_pointer_t addr32; 609 int error; 610 611 SCARG(&ua, shmid) = SCARG(uap, a1); 612 SCARG(&ua, shmaddr) = SCARG_P32(uap, ptr); 613 SCARG(&ua, shmflg) = SCARG(uap, a2); 614 615 if ((error = sys_shmat(l, &ua, retval))) 616 return error; 617 618 NETBSD32PTR32(addr32, (const void *)(uintptr_t)retval[0]); 619 620 error = copyout(&addr32, NETBSD32IPTR64(SCARG(uap, a3)), sizeof addr32); 621 if (error == 0) 622 retval[0] = 0; 623 624 return error; 625 } 626 627 static int 628 linux32_shmdt(struct lwp *l, const struct linux32_sys_ipc_args *uap, 629 register_t *retval) 630 { 631 struct sys_shmdt_args ua; 632 633 SCARG(&ua, shmaddr) = SCARG_P32(uap, ptr); 634 635 return sys_shmdt(l, &ua, retval); 636 } 637 638 static int 639 linux32_shmget(struct lwp *l, const struct linux32_sys_ipc_args *uap, 640 register_t *retval) 641 { 642 struct sys_shmget_args ua; 643 644 SCARG(&ua, key) = SCARG(uap, a1); 645 SCARG(&ua, size) = SCARG(uap, a2); 646 SCARG(&ua, shmflg) = SCARG(uap, a3) | _SHM_RMLINGER; 647 648 return sys_shmget(l, &ua, retval); 649 } 650 651 static int 652 linux32_shmctl(struct lwp *l, const struct linux32_sys_ipc_args *uap, 653 register_t *retval) 654 { 655 int shmid, cmd, error; 656 struct shmid_ds bs; 657 struct linux32_shmid_ds ls; 658 struct linux32_shmid64_ds ls64; 659 660 shmid = SCARG(uap, a1); 661 cmd = SCARG(uap, a2); 662 663 switch (cmd & ~LINUX32_IPC_64) { 664 665 case LINUX32_SHM_STAT: 666 return ENOSYS; 667 668 case LINUX32_IPC_STAT: 669 error = shmctl1(l, shmid, IPC_STAT, &bs); 670 if (error != 0) 671 return error; 672 if (cmd & LINUX32_IPC_64) { 673 bsd_to_linux32_shmid64_ds(&bs, &ls64); 674 error = copyout(&ls64, SCARG_P32(uap, ptr), sizeof ls64); 675 } else { 676 bsd_to_linux32_shmid_ds(&bs, &ls); 677 error = copyout(&ls, SCARG_P32(uap, ptr), sizeof ls); 678 } 679 return error; 680 681 case LINUX32_IPC_SET: 682 if (cmd & LINUX32_IPC_64) { 683 error = copyin(SCARG_P32(uap, ptr), &ls64, sizeof ls64); 684 linux32_to_bsd_shmid64_ds(&ls64, &bs); 685 } else { 686 error = copyin(SCARG_P32(uap, ptr), &ls, sizeof ls); 687 linux32_to_bsd_shmid_ds(&ls, &bs); 688 } 689 if (error != 0) 690 return error; 691 return shmctl1(l, shmid, IPC_SET, &bs); 692 693 case LINUX32_IPC_RMID: 694 return shmctl1(l, shmid, IPC_RMID, NULL); 695 696 case LINUX32_SHM_LOCK: 697 return shmctl1(l, shmid, SHM_LOCK, NULL); 698 699 case LINUX32_SHM_UNLOCK: 700 return shmctl1(l, shmid, SHM_UNLOCK, NULL); 701 702 case LINUX32_IPC_INFO: 703 case LINUX32_SHM_INFO: 704 return ENOSYS; 705 706 default: 707 return EINVAL; 708 } 709 } 710 #endif /* SYSVSHM */ 711
Indexes created Fri Oct 03 02:09:57 GMT 2025