Annotation of sys/compat/svr4/svr4_fcntl.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: svr4_fcntl.c,v 1.22 2002/03/14 01:26:51 millert Exp $ */
! 2: /* $NetBSD: svr4_fcntl.c,v 1.14 1995/10/14 20:24:24 christos Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1997 Theo de Raadt
! 6: * Copyright (c) 1994 Christos Zoulas
! 7: * All rights reserved.
! 8: *
! 9: * Redistribution and use in source and binary forms, with or without
! 10: * modification, are permitted provided that the following conditions
! 11: * are met:
! 12: * 1. Redistributions of source code must retain the above copyright
! 13: * notice, this list of conditions and the following disclaimer.
! 14: * 2. Redistributions in binary form must reproduce the above copyright
! 15: * notice, this list of conditions and the following disclaimer in the
! 16: * documentation and/or other materials provided with the distribution.
! 17: * 3. The name of the author may not be used to endorse or promote products
! 18: * derived from this software without specific prior written permission
! 19: *
! 20: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 21: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 22: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 23: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 24: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 25: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 26: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 27: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 28: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 29: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 30: */
! 31:
! 32: #include <sys/param.h>
! 33: #include <sys/systm.h>
! 34: #include <sys/namei.h>
! 35: #include <sys/proc.h>
! 36: #include <sys/file.h>
! 37: #include <sys/stat.h>
! 38: #include <sys/vnode.h>
! 39: #include <sys/filedesc.h>
! 40: #include <sys/ioctl.h>
! 41: #include <sys/kernel.h>
! 42: #include <sys/mount.h>
! 43: #include <sys/malloc.h>
! 44: #include <sys/poll.h>
! 45: #include <sys/syscallargs.h>
! 46:
! 47: #include <compat/svr4/svr4_types.h>
! 48: #include <compat/svr4/svr4_signal.h>
! 49: #include <compat/svr4/svr4_syscallargs.h>
! 50: #include <compat/svr4/svr4_util.h>
! 51: #include <compat/svr4/svr4_fcntl.h>
! 52:
! 53: static u_long svr4_to_bsd_cmd(u_long);
! 54: static int svr4_to_bsd_flags(int);
! 55: static int bsd_to_svr4_flags(int);
! 56: static void bsd_to_svr4_flock(struct flock *, struct svr4_flock *);
! 57: static void svr4_to_bsd_flock(struct svr4_flock *, struct flock *);
! 58: static void bsd_to_svr3_flock(struct flock *, struct svr4_flock_svr3 *);
! 59: static void svr3_to_bsd_flock(struct svr4_flock_svr3 *, struct flock *);
! 60: static int fd_truncate(struct proc *, int, struct flock *, register_t *);
! 61:
! 62: static u_long
! 63: svr4_to_bsd_cmd(cmd)
! 64: u_long cmd;
! 65: {
! 66: switch (cmd) {
! 67: case SVR4_F_DUPFD:
! 68: return F_DUPFD;
! 69: case SVR4_F_GETFD:
! 70: return F_GETFD;
! 71: case SVR4_F_SETFD:
! 72: return F_SETFD;
! 73: case SVR4_F_GETFL:
! 74: return F_GETFL;
! 75: case SVR4_F_SETFL:
! 76: return F_SETFL;
! 77: case SVR4_F_GETLK:
! 78: case SVR4_F_GETLK_SVR3:
! 79: return F_GETLK;
! 80: case SVR4_F_SETLK:
! 81: return F_SETLK;
! 82: case SVR4_F_SETLKW:
! 83: return F_SETLKW;
! 84: default:
! 85: return -1;
! 86: }
! 87: }
! 88:
! 89:
! 90: static int
! 91: svr4_to_bsd_flags(l)
! 92: int l;
! 93: {
! 94: int r = 0;
! 95: r |= (l & SVR4_O_RDONLY) ? O_RDONLY : 0;
! 96: r |= (l & SVR4_O_WRONLY) ? O_WRONLY : 0;
! 97: r |= (l & SVR4_O_RDWR) ? O_RDWR : 0;
! 98: r |= (l & SVR4_O_NDELAY) ? O_NONBLOCK : 0;
! 99: r |= (l & SVR4_O_APPEND) ? O_APPEND : 0;
! 100: #if 0
! 101: /* Dellism ??? */
! 102: r |= (l & SVR4_O_RAIOSIG) ? O_ASYNC : 0;
! 103: #endif
! 104: r |= (l & SVR4_O_SYNC) ? O_FSYNC : 0;
! 105: r |= (l & SVR4_O_RSYNC) ? O_RSYNC : 0;
! 106: r |= (l & SVR4_O_DSYNC) ? O_DSYNC : 0;
! 107: r |= (l & SVR4_O_NONBLOCK) ? O_NONBLOCK : 0;
! 108: r |= (l & SVR4_O_PRIV) ? O_EXLOCK : 0;
! 109: r |= (l & SVR4_O_CREAT) ? O_CREAT : 0;
! 110: r |= (l & SVR4_O_TRUNC) ? O_TRUNC : 0;
! 111: r |= (l & SVR4_O_EXCL) ? O_EXCL : 0;
! 112: r |= (l & SVR4_O_NOCTTY) ? O_NOCTTY : 0;
! 113: return r;
! 114: }
! 115:
! 116:
! 117: static int
! 118: bsd_to_svr4_flags(l)
! 119: int l;
! 120: {
! 121: int r = 0;
! 122: r |= (l & O_RDONLY) ? SVR4_O_RDONLY : 0;
! 123: r |= (l & O_WRONLY) ? SVR4_O_WRONLY : 0;
! 124: r |= (l & O_RDWR) ? SVR4_O_RDWR : 0;
! 125: r |= (l & O_NDELAY) ? SVR4_O_NONBLOCK : 0;
! 126: r |= (l & O_APPEND) ? SVR4_O_APPEND : 0;
! 127: #if 0
! 128: /* Dellism ??? */
! 129: r |= (l & O_ASYNC) ? SVR4_O_RAIOSIG : 0;
! 130: #endif
! 131: r |= (l & O_FSYNC) ? SVR4_O_SYNC : 0;
! 132: r |= (l & O_RSYNC) ? SVR4_O_RSYNC : 0;
! 133: r |= (l & O_DSYNC) ? SVR4_O_DSYNC : 0;
! 134: r |= (l & O_NONBLOCK) ? SVR4_O_NONBLOCK : 0;
! 135: r |= (l & O_EXLOCK) ? SVR4_O_PRIV : 0;
! 136: r |= (l & O_CREAT) ? SVR4_O_CREAT : 0;
! 137: r |= (l & O_TRUNC) ? SVR4_O_TRUNC : 0;
! 138: r |= (l & O_EXCL) ? SVR4_O_EXCL : 0;
! 139: r |= (l & O_NOCTTY) ? SVR4_O_NOCTTY : 0;
! 140: return r;
! 141: }
! 142:
! 143: static void
! 144: bsd_to_svr4_flock(iflp, oflp)
! 145: struct flock *iflp;
! 146: struct svr4_flock *oflp;
! 147: {
! 148: switch (iflp->l_type) {
! 149: case F_RDLCK:
! 150: oflp->l_type = SVR4_F_RDLCK;
! 151: break;
! 152: case F_WRLCK:
! 153: oflp->l_type = SVR4_F_WRLCK;
! 154: break;
! 155: case F_UNLCK:
! 156: oflp->l_type = SVR4_F_UNLCK;
! 157: break;
! 158: default:
! 159: oflp->l_type = -1;
! 160: break;
! 161: }
! 162:
! 163: oflp->l_whence = (short) iflp->l_whence;
! 164: oflp->l_start = (svr4_off_t) iflp->l_start;
! 165: oflp->l_len = (svr4_off_t) iflp->l_len;
! 166: oflp->l_sysid = 0;
! 167: oflp->l_pid = (svr4_pid_t) iflp->l_pid;
! 168: }
! 169:
! 170: static void
! 171: svr4_to_bsd_flock(iflp, oflp)
! 172: struct svr4_flock *iflp;
! 173: struct flock *oflp;
! 174: {
! 175: switch (iflp->l_type) {
! 176: case SVR4_F_RDLCK:
! 177: oflp->l_type = F_RDLCK;
! 178: break;
! 179: case SVR4_F_WRLCK:
! 180: oflp->l_type = F_WRLCK;
! 181: break;
! 182: case SVR4_F_UNLCK:
! 183: oflp->l_type = F_UNLCK;
! 184: break;
! 185: default:
! 186: oflp->l_type = -1;
! 187: break;
! 188: }
! 189:
! 190: oflp->l_whence = iflp->l_whence;
! 191: oflp->l_start = (off_t) iflp->l_start;
! 192: oflp->l_len = (off_t) iflp->l_len;
! 193: oflp->l_pid = (pid_t) iflp->l_pid;
! 194: }
! 195:
! 196: static void
! 197: bsd_to_svr3_flock(iflp, oflp)
! 198: struct flock *iflp;
! 199: struct svr4_flock_svr3 *oflp;
! 200: {
! 201: switch (iflp->l_type) {
! 202: case F_RDLCK:
! 203: oflp->l_type = SVR4_F_RDLCK;
! 204: break;
! 205: case F_WRLCK:
! 206: oflp->l_type = SVR4_F_WRLCK;
! 207: break;
! 208: case F_UNLCK:
! 209: oflp->l_type = SVR4_F_UNLCK;
! 210: break;
! 211: default:
! 212: oflp->l_type = -1;
! 213: break;
! 214: }
! 215:
! 216: oflp->l_whence = (short) iflp->l_whence;
! 217: oflp->l_start = (svr4_off_t) iflp->l_start;
! 218: oflp->l_len = (svr4_off_t) iflp->l_len;
! 219: oflp->l_sysid = 0;
! 220: oflp->l_pid = (svr4_pid_t) iflp->l_pid;
! 221: }
! 222:
! 223:
! 224: static void
! 225: svr3_to_bsd_flock(iflp, oflp)
! 226: struct svr4_flock_svr3 *iflp;
! 227: struct flock *oflp;
! 228: {
! 229: switch (iflp->l_type) {
! 230: case SVR4_F_RDLCK:
! 231: oflp->l_type = F_RDLCK;
! 232: break;
! 233: case SVR4_F_WRLCK:
! 234: oflp->l_type = F_WRLCK;
! 235: break;
! 236: case SVR4_F_UNLCK:
! 237: oflp->l_type = F_UNLCK;
! 238: break;
! 239: default:
! 240: oflp->l_type = -1;
! 241: break;
! 242: }
! 243:
! 244: oflp->l_whence = iflp->l_whence;
! 245: oflp->l_start = (off_t) iflp->l_start;
! 246: oflp->l_len = (off_t) iflp->l_len;
! 247: oflp->l_pid = (pid_t) iflp->l_pid;
! 248: }
! 249:
! 250: static int
! 251: fd_truncate(p, fd, flp, retval)
! 252: struct proc *p;
! 253: int fd;
! 254: struct flock *flp;
! 255: register_t *retval;
! 256: {
! 257: struct filedesc *fdp = p->p_fd;
! 258: struct file *fp;
! 259: off_t start, length;
! 260: struct vnode *vp;
! 261: struct vattr vattr;
! 262: int error;
! 263: struct sys_ftruncate_args ft;
! 264:
! 265: /*
! 266: * We only support truncating the file.
! 267: */
! 268: if ((fp = fd_getfile(fdp, fd)) == NULL)
! 269: return EBADF;
! 270:
! 271: vp = (struct vnode *)fp->f_data;
! 272: if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO)
! 273: return ESPIPE;
! 274:
! 275: FREF(fp);
! 276:
! 277: if ((error = VOP_GETATTR(vp, &vattr, p->p_ucred, p)) != 0)
! 278: goto out;
! 279:
! 280: length = vattr.va_size;
! 281:
! 282: switch (flp->l_whence) {
! 283: case SEEK_CUR:
! 284: start = fp->f_offset + flp->l_start;
! 285: break;
! 286:
! 287: case SEEK_END:
! 288: start = flp->l_start + length;
! 289: break;
! 290:
! 291: case SEEK_SET:
! 292: start = flp->l_start;
! 293: break;
! 294:
! 295: default:
! 296: error = EINVAL;
! 297: goto out;
! 298: }
! 299:
! 300: if (start + flp->l_len < length) {
! 301: /* We don't support free'ing in the middle of the file */
! 302: error = EINVAL;
! 303: goto out;
! 304: }
! 305:
! 306: SCARG(&ft, fd) = fd;
! 307: SCARG(&ft, length) = start;
! 308:
! 309: error = sys_ftruncate(p, &ft, retval);
! 310: out:
! 311: FRELE(fp);
! 312: return (error);
! 313: }
! 314:
! 315: int
! 316: svr4_sys_open(p, v, retval)
! 317: register struct proc *p;
! 318: void *v;
! 319: register_t *retval;
! 320: {
! 321: struct svr4_sys_open_args *uap = v;
! 322: int error;
! 323: struct sys_open_args cup;
! 324:
! 325: caddr_t sg = stackgap_init(p->p_emul);
! 326:
! 327: SCARG(&cup, flags) = svr4_to_bsd_flags(SCARG(uap, flags));
! 328:
! 329: if (SCARG(&cup, flags) & O_CREAT)
! 330: SVR4_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
! 331: else
! 332: SVR4_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 333:
! 334: SCARG(&cup, path) = SCARG(uap, path);
! 335: SCARG(&cup, mode) = SCARG(uap, mode);
! 336: error = sys_open(p, &cup, retval);
! 337:
! 338: if (error)
! 339: return error;
! 340:
! 341: if (!(SCARG(&cup, flags) & O_NOCTTY) && SESS_LEADER(p) &&
! 342: !(p->p_flag & P_CONTROLT)) {
! 343: struct filedesc *fdp = p->p_fd;
! 344: struct file *fp;
! 345:
! 346: if ((fp = fd_getfile(fdp, *retval)) == NULL)
! 347: return (EBADF);
! 348: FREF(fp);
! 349: /* ignore any error, just give it a try */
! 350: if (fp->f_type == DTYPE_VNODE)
! 351: (fp->f_ops->fo_ioctl) (fp, TIOCSCTTY, (caddr_t) 0, p);
! 352: FRELE(fp);
! 353: }
! 354: return 0;
! 355: }
! 356:
! 357: int
! 358: svr4_sys_open64(p, v, retval)
! 359: register struct proc *p;
! 360: void *v;
! 361: register_t *retval;
! 362: {
! 363: return svr4_sys_open(p, v, retval);
! 364: }
! 365:
! 366: int
! 367: svr4_sys_creat(p, v, retval)
! 368: register struct proc *p;
! 369: void *v;
! 370: register_t *retval;
! 371: {
! 372: struct svr4_sys_creat_args *uap = v;
! 373: struct sys_open_args cup;
! 374:
! 375: caddr_t sg = stackgap_init(p->p_emul);
! 376: SVR4_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 377:
! 378: SCARG(&cup, path) = SCARG(uap, path);
! 379: SCARG(&cup, mode) = SCARG(uap, mode);
! 380: SCARG(&cup, flags) = O_WRONLY | O_CREAT | O_TRUNC;
! 381:
! 382: return sys_open(p, &cup, retval);
! 383: }
! 384:
! 385: int
! 386: svr4_sys_creat64(p, v, retval)
! 387: register struct proc *p;
! 388: void *v;
! 389: register_t *retval;
! 390: {
! 391: return (svr4_sys_creat(p, v, retval));
! 392: }
! 393:
! 394: int
! 395: svr4_sys_llseek(p, v, retval)
! 396: register struct proc *p;
! 397: void *v;
! 398: register_t *retval;
! 399: {
! 400: struct svr4_sys_llseek_args *uap = v;
! 401: struct sys_lseek_args ap;
! 402:
! 403: SCARG(&ap, fd) = SCARG(uap, fd);
! 404:
! 405: #if BYTE_ORDER == BIG_ENDIAN
! 406: SCARG(&ap, offset) = (((long long) SCARG(uap, offset1)) << 32) |
! 407: SCARG(uap, offset2);
! 408: #else
! 409: SCARG(&ap, offset) = (((long long) SCARG(uap, offset2)) << 32) |
! 410: SCARG(uap, offset1);
! 411: #endif
! 412: SCARG(&ap, whence) = SCARG(uap, whence);
! 413:
! 414: return sys_lseek(p, &ap, retval);
! 415: }
! 416:
! 417: int
! 418: svr4_sys_access(p, v, retval)
! 419: register struct proc *p;
! 420: void *v;
! 421: register_t *retval;
! 422: {
! 423: struct svr4_sys_access_args *uap = v;
! 424: struct sys_access_args cup;
! 425:
! 426: caddr_t sg = stackgap_init(p->p_emul);
! 427: SVR4_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 428:
! 429: SCARG(&cup, path) = SCARG(uap, path);
! 430: SCARG(&cup, flags) = SCARG(uap, flags);
! 431:
! 432: return sys_access(p, &cup, retval);
! 433: }
! 434:
! 435: int
! 436: svr4_sys_pread(p, v, retval)
! 437: register struct proc *p;
! 438: void *v;
! 439: register_t *retval;
! 440: {
! 441: struct svr4_sys_pread_args *uap = v;
! 442: struct sys_pread_args pra;
! 443:
! 444: SCARG(&pra, fd) = SCARG(uap, fd);
! 445: SCARG(&pra, buf) = SCARG(uap, buf);
! 446: SCARG(&pra, nbyte) = SCARG(uap, nbyte);
! 447: SCARG(&pra, offset) = SCARG(uap, off);
! 448:
! 449: return (sys_pread(p, &pra, retval));
! 450: }
! 451:
! 452: int
! 453: svr4_sys_pread64(p, v, retval)
! 454: register struct proc *p;
! 455: void *v;
! 456: register_t *retval;
! 457: {
! 458: struct svr4_sys_pread64_args *uap = v;
! 459: struct sys_pread_args pra;
! 460:
! 461: SCARG(&pra, fd) = SCARG(uap, fd);
! 462: SCARG(&pra, buf) = SCARG(uap, buf);
! 463: SCARG(&pra, nbyte) = SCARG(uap, nbyte);
! 464: SCARG(&pra, offset) = SCARG(uap, off);
! 465:
! 466: return (sys_pread(p, &pra, retval));
! 467: }
! 468:
! 469: int
! 470: svr4_sys_pwrite(p, v, retval)
! 471: register struct proc *p;
! 472: void *v;
! 473: register_t *retval;
! 474: {
! 475: struct svr4_sys_pwrite_args *uap = v;
! 476: struct sys_pwrite_args pwa;
! 477:
! 478: SCARG(&pwa, fd) = SCARG(uap, fd);
! 479: SCARG(&pwa, buf) = SCARG(uap, buf);
! 480: SCARG(&pwa, nbyte) = SCARG(uap, nbyte);
! 481: SCARG(&pwa, offset) = SCARG(uap, off);
! 482:
! 483: return (sys_pwrite(p, &pwa, retval));
! 484: }
! 485:
! 486: int
! 487: svr4_sys_pwrite64(p, v, retval)
! 488: register struct proc *p;
! 489: void *v;
! 490: register_t *retval;
! 491: {
! 492: struct svr4_sys_pwrite64_args *uap = v;
! 493: struct sys_pwrite_args pwa;
! 494:
! 495: SCARG(&pwa, fd) = SCARG(uap, fd);
! 496: SCARG(&pwa, buf) = SCARG(uap, buf);
! 497: SCARG(&pwa, nbyte) = SCARG(uap, nbyte);
! 498: SCARG(&pwa, offset) = SCARG(uap, off);
! 499:
! 500: return (sys_pwrite(p, &pwa, retval));
! 501: }
! 502:
! 503: int
! 504: svr4_sys_fcntl(p, v, retval)
! 505: register struct proc *p;
! 506: void *v;
! 507: register_t *retval;
! 508: {
! 509: struct svr4_sys_fcntl_args *uap = v;
! 510: int error;
! 511: struct sys_fcntl_args fa;
! 512:
! 513: SCARG(&fa, fd) = SCARG(uap, fd);
! 514: SCARG(&fa, cmd) = svr4_to_bsd_cmd(SCARG(uap, cmd));
! 515:
! 516: switch (SCARG(&fa, cmd)) {
! 517: case F_DUPFD:
! 518: case F_GETFD:
! 519: case F_SETFD:
! 520: SCARG(&fa, arg) = SCARG(uap, arg);
! 521: return sys_fcntl(p, &fa, retval);
! 522:
! 523: case F_GETFL:
! 524: SCARG(&fa, arg) = SCARG(uap, arg);
! 525: error = sys_fcntl(p, &fa, retval);
! 526: if (error)
! 527: return error;
! 528: *retval = bsd_to_svr4_flags(*retval);
! 529: return error;
! 530:
! 531: case F_SETFL:
! 532: {
! 533: /*
! 534: * we must save the O_ASYNC flag, as that is
! 535: * handled by ioctl(_, I_SETSIG, _) emulation.
! 536: */
! 537: register_t flags;
! 538: int cmd;
! 539:
! 540: cmd = SCARG(&fa, cmd); /* save it for a while */
! 541:
! 542: SCARG(&fa, cmd) = F_GETFL;
! 543: if ((error = sys_fcntl(p, &fa, &flags)) != 0)
! 544: return error;
! 545: flags &= O_ASYNC;
! 546: flags |= svr4_to_bsd_flags((u_long) SCARG(uap, arg));
! 547: SCARG(&fa, cmd) = cmd;
! 548: SCARG(&fa, arg) = (void *) flags;
! 549: return sys_fcntl(p, &fa, retval);
! 550: }
! 551:
! 552: case F_GETLK:
! 553: if (SCARG(uap, cmd) == SVR4_F_GETLK_SVR3) {
! 554: struct svr4_flock_svr3 ifl;
! 555: struct flock *flp, fl;
! 556: caddr_t sg = stackgap_init(p->p_emul);
! 557:
! 558: flp = stackgap_alloc(&sg, sizeof(*flp));
! 559: error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&ifl,
! 560: sizeof ifl);
! 561: if (error)
! 562: return error;
! 563: svr3_to_bsd_flock(&ifl, &fl);
! 564:
! 565: error = copyout(&fl, flp, sizeof fl);
! 566: if (error)
! 567: return error;
! 568:
! 569: SCARG(&fa, fd) = SCARG(uap, fd);
! 570: SCARG(&fa, cmd) = F_GETLK;
! 571: SCARG(&fa, arg) = (void *)flp;
! 572: error = sys_fcntl(p, &fa, retval);
! 573: if (error)
! 574: return error;
! 575:
! 576: error = copyin(flp, &fl, sizeof fl);
! 577: if (error)
! 578: return error;
! 579:
! 580: bsd_to_svr3_flock(&fl, &ifl);
! 581:
! 582: return copyout((caddr_t)&ifl, (caddr_t)SCARG(uap, arg),
! 583: sizeof ifl);
! 584: }
! 585: /*FALLTHROUGH*/
! 586: case F_SETLK:
! 587: case F_SETLKW:
! 588: {
! 589: struct svr4_flock ifl;
! 590: struct flock *flp, fl;
! 591: caddr_t sg = stackgap_init(p->p_emul);
! 592:
! 593: flp = stackgap_alloc(&sg, sizeof(struct flock));
! 594: SCARG(&fa, arg) = (void *) flp;
! 595:
! 596: error = copyin(SCARG(uap, arg), &ifl, sizeof ifl);
! 597: if (error)
! 598: return error;
! 599:
! 600: svr4_to_bsd_flock(&ifl, &fl);
! 601:
! 602: error = copyout(&fl, flp, sizeof fl);
! 603: if (error)
! 604: return error;
! 605:
! 606: error = sys_fcntl(p, &fa, retval);
! 607: if (error || SCARG(&fa, cmd) != F_GETLK)
! 608: return error;
! 609:
! 610: error = copyin(flp, &fl, sizeof fl);
! 611: if (error)
! 612: return error;
! 613:
! 614: bsd_to_svr4_flock(&fl, &ifl);
! 615:
! 616: return copyout(&ifl, SCARG(uap, arg), sizeof ifl);
! 617: }
! 618: case -1:
! 619: switch (SCARG(uap, cmd)) {
! 620: case SVR4_F_DUP2FD:
! 621: {
! 622: struct sys_dup2_args du;
! 623:
! 624: SCARG(&du, from) = SCARG(uap, fd);
! 625: SCARG(&du, to) = (int)SCARG(uap, arg);
! 626: error = sys_dup2(p, &du, retval);
! 627: if (error)
! 628: return error;
! 629: *retval = SCARG(&du, to);
! 630: return 0;
! 631: }
! 632: case SVR4_F_FREESP:
! 633: {
! 634: struct svr4_flock ifl;
! 635: struct flock fl;
! 636:
! 637: error = copyin(SCARG(uap, arg), &ifl,
! 638: sizeof ifl);
! 639: if (error)
! 640: return error;
! 641: svr4_to_bsd_flock(&ifl, &fl);
! 642: return fd_truncate(p, SCARG(uap, fd), &fl,
! 643: retval);
! 644: }
! 645:
! 646: default:
! 647: return ENOSYS;
! 648: }
! 649:
! 650: default:
! 651: return ENOSYS;
! 652: }
! 653: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to svr4_fcntl.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / svr4