Annotation of sys/compat/linux/linux_file.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: linux_file.c,v 1.23 2006/09/25 07:12:57 otto Exp $ */
! 2: /* $NetBSD: linux_file.c,v 1.15 1996/05/20 01:59:09 fvdl Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995 Frank van der Linden
! 6: * All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: * 3. All advertising materials mentioning features or use of this software
! 17: * must display the following acknowledgement:
! 18: * This product includes software developed for the NetBSD Project
! 19: * by Frank van der Linden
! 20: * 4. The name of the author may not be used to endorse or promote products
! 21: * derived from this software without specific prior written permission
! 22: *
! 23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 25: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 26: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 27: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 28: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 29: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 30: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 31: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 32: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 33: */
! 34:
! 35: #include <sys/param.h>
! 36: #include <sys/systm.h>
! 37: #include <sys/namei.h>
! 38: #include <sys/proc.h>
! 39: #include <sys/file.h>
! 40: #include <sys/stat.h>
! 41: #include <sys/filedesc.h>
! 42: #include <sys/ioctl.h>
! 43: #include <sys/kernel.h>
! 44: #include <sys/mount.h>
! 45: #include <sys/signalvar.h>
! 46: #include <sys/uio.h>
! 47: #include <sys/malloc.h>
! 48: #include <sys/vnode.h>
! 49: #include <sys/tty.h>
! 50: #include <sys/conf.h>
! 51:
! 52: #include <sys/syscallargs.h>
! 53:
! 54: #include <compat/linux/linux_types.h>
! 55: #include <compat/linux/linux_signal.h>
! 56: #include <compat/linux/linux_syscallargs.h>
! 57: #include <compat/linux/linux_fcntl.h>
! 58: #include <compat/linux/linux_util.h>
! 59:
! 60: #include <machine/linux_machdep.h>
! 61:
! 62: static int linux_to_bsd_ioflags(int);
! 63: static int bsd_to_linux_ioflags(int);
! 64: static void bsd_to_linux_flock(struct flock *, struct linux_flock *);
! 65: static void linux_to_bsd_flock(struct linux_flock *, struct flock *);
! 66: static void bsd_to_linux_stat(struct stat *, struct linux_stat *);
! 67: static int linux_stat1(struct proc *, void *, register_t *, int);
! 68:
! 69:
! 70: /*
! 71: * Some file-related calls are handled here. The usual flag conversion
! 72: * an structure conversion is done, and alternate emul path searching.
! 73: */
! 74:
! 75: /*
! 76: * The next two functions convert between the Linux and OpenBSD values
! 77: * of the flags used in open(2) and fcntl(2).
! 78: */
! 79: static int
! 80: linux_to_bsd_ioflags(lflags)
! 81: int lflags;
! 82: {
! 83: int res = 0;
! 84:
! 85: res |= cvtto_bsd_mask(lflags, LINUX_O_WRONLY, O_WRONLY);
! 86: res |= cvtto_bsd_mask(lflags, LINUX_O_RDONLY, O_RDONLY);
! 87: res |= cvtto_bsd_mask(lflags, LINUX_O_RDWR, O_RDWR);
! 88: res |= cvtto_bsd_mask(lflags, LINUX_O_CREAT, O_CREAT);
! 89: res |= cvtto_bsd_mask(lflags, LINUX_O_EXCL, O_EXCL);
! 90: res |= cvtto_bsd_mask(lflags, LINUX_O_NOCTTY, O_NOCTTY);
! 91: res |= cvtto_bsd_mask(lflags, LINUX_O_TRUNC, O_TRUNC);
! 92: res |= cvtto_bsd_mask(lflags, LINUX_O_NDELAY, O_NDELAY);
! 93: res |= cvtto_bsd_mask(lflags, LINUX_O_SYNC, O_SYNC);
! 94: res |= cvtto_bsd_mask(lflags, LINUX_FASYNC, O_ASYNC);
! 95: res |= cvtto_bsd_mask(lflags, LINUX_O_APPEND, O_APPEND);
! 96:
! 97: return res;
! 98: }
! 99:
! 100: static int
! 101: bsd_to_linux_ioflags(bflags)
! 102: int bflags;
! 103: {
! 104: int res = 0;
! 105:
! 106: res |= cvtto_linux_mask(bflags, O_WRONLY, LINUX_O_WRONLY);
! 107: res |= cvtto_linux_mask(bflags, O_RDONLY, LINUX_O_RDONLY);
! 108: res |= cvtto_linux_mask(bflags, O_RDWR, LINUX_O_RDWR);
! 109: res |= cvtto_linux_mask(bflags, O_CREAT, LINUX_O_CREAT);
! 110: res |= cvtto_linux_mask(bflags, O_EXCL, LINUX_O_EXCL);
! 111: res |= cvtto_linux_mask(bflags, O_NOCTTY, LINUX_O_NOCTTY);
! 112: res |= cvtto_linux_mask(bflags, O_TRUNC, LINUX_O_TRUNC);
! 113: res |= cvtto_linux_mask(bflags, O_NDELAY, LINUX_O_NDELAY);
! 114: res |= cvtto_linux_mask(bflags, O_SYNC, LINUX_O_SYNC);
! 115: res |= cvtto_linux_mask(bflags, O_ASYNC, LINUX_FASYNC);
! 116: res |= cvtto_linux_mask(bflags, O_APPEND, LINUX_O_APPEND);
! 117:
! 118: return res;
! 119: }
! 120:
! 121: /*
! 122: * creat(2) is an obsolete function, but it's present as a Linux
! 123: * system call, so let's deal with it.
! 124: *
! 125: * Just call open(2) with the TRUNC, CREAT and WRONLY flags.
! 126: */
! 127: int
! 128: linux_sys_creat(p, v, retval)
! 129: struct proc *p;
! 130: void *v;
! 131: register_t *retval;
! 132: {
! 133: struct linux_sys_creat_args /* {
! 134: syscallarg(char *) path;
! 135: syscallarg(int) mode;
! 136: } */ *uap = v;
! 137: struct sys_open_args oa;
! 138: caddr_t sg;
! 139:
! 140: sg = stackgap_init(p->p_emul);
! 141: LINUX_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
! 142:
! 143: SCARG(&oa, path) = SCARG(uap, path);
! 144: SCARG(&oa, flags) = O_CREAT | O_TRUNC | O_WRONLY;
! 145: SCARG(&oa, mode) = SCARG(uap, mode);
! 146:
! 147: return sys_open(p, &oa, retval);
! 148: }
! 149:
! 150: /*
! 151: * open(2). Take care of the different flag values, and let the
! 152: * OpenBSD syscall do the real work. See if this operation
! 153: * gives the current process a controlling terminal.
! 154: * (XXX is this necessary?)
! 155: */
! 156: int
! 157: linux_sys_open(p, v, retval)
! 158: struct proc *p;
! 159: void *v;
! 160: register_t *retval;
! 161: {
! 162: struct linux_sys_open_args /* {
! 163: syscallarg(char *) path;
! 164: syscallarg(int) flags;
! 165: syscallarg(int) mode;
! 166: } */ *uap = v;
! 167: int error, fl;
! 168: struct sys_open_args boa;
! 169: caddr_t sg;
! 170:
! 171: sg = stackgap_init(p->p_emul);
! 172:
! 173: fl = linux_to_bsd_ioflags(SCARG(uap, flags));
! 174:
! 175: if (fl & O_CREAT)
! 176: LINUX_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
! 177: else
! 178: LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 179:
! 180: SCARG(&boa, path) = SCARG(uap, path);
! 181: SCARG(&boa, flags) = fl;
! 182: SCARG(&boa, mode) = SCARG(uap, mode);
! 183:
! 184: if ((error = sys_open(p, &boa, retval)))
! 185: return error;
! 186:
! 187: /*
! 188: * this bit from sunos_misc.c (and svr4_fcntl.c).
! 189: * If we are a session leader, and we don't have a controlling
! 190: * terminal yet, and the O_NOCTTY flag is not set, try to make
! 191: * this the controlling terminal.
! 192: */
! 193: if (!(fl & O_NOCTTY) && SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) {
! 194: struct filedesc *fdp = p->p_fd;
! 195: struct file *fp;
! 196:
! 197: if ((fp = fd_getfile(fdp, *retval)) == NULL)
! 198: return (EBADF);
! 199: FREF(fp);
! 200: if (fp->f_type == DTYPE_VNODE)
! 201: (fp->f_ops->fo_ioctl) (fp, TIOCSCTTY, (caddr_t) 0, p);
! 202: FRELE(fp);
! 203: }
! 204: return 0;
! 205: }
! 206:
! 207: /*
! 208: * This appears to be part of a Linux attempt to switch to 64 bits file sizes.
! 209: */
! 210: int
! 211: linux_sys_llseek(p, v, retval)
! 212: struct proc *p;
! 213: void *v;
! 214: register_t *retval;
! 215: {
! 216: struct linux_sys_llseek_args /* {
! 217: syscallarg(int) fd;
! 218: syscallarg(uint32_t) ohigh;
! 219: syscallarg(uint32_t) olow;
! 220: syscallarg(caddr_t) res;
! 221: syscallarg(int) whence;
! 222: } */ *uap = v;
! 223: struct sys_lseek_args bla;
! 224: int error;
! 225: off_t off;
! 226:
! 227: off = SCARG(uap, olow) | (((off_t) SCARG(uap, ohigh)) << 32);
! 228:
! 229: SCARG(&bla, fd) = SCARG(uap, fd);
! 230: SCARG(&bla, offset) = off;
! 231: SCARG(&bla, whence) = SCARG(uap, whence);
! 232:
! 233: if ((error = sys_lseek(p, &bla, retval)))
! 234: return error;
! 235:
! 236: if ((error = copyout(retval, SCARG(uap, res), sizeof (off_t))))
! 237: return error;
! 238:
! 239: retval[0] = 0;
! 240: return 0;
! 241: }
! 242:
! 243: /*
! 244: * The next two functions take care of converting the flock
! 245: * structure back and forth between Linux and OpenBSD format.
! 246: * The only difference in the structures is the order of
! 247: * the fields, and the 'whence' value.
! 248: */
! 249: static void
! 250: bsd_to_linux_flock(bfp, lfp)
! 251: struct flock *bfp;
! 252: struct linux_flock *lfp;
! 253: {
! 254:
! 255: lfp->l_start = bfp->l_start;
! 256: lfp->l_len = bfp->l_len;
! 257: lfp->l_pid = bfp->l_pid;
! 258: lfp->l_whence = bfp->l_whence;
! 259: switch (bfp->l_type) {
! 260: case F_RDLCK:
! 261: lfp->l_type = LINUX_F_RDLCK;
! 262: break;
! 263: case F_UNLCK:
! 264: lfp->l_type = LINUX_F_UNLCK;
! 265: break;
! 266: case F_WRLCK:
! 267: lfp->l_type = LINUX_F_WRLCK;
! 268: break;
! 269: }
! 270: }
! 271:
! 272: static void
! 273: linux_to_bsd_flock(lfp, bfp)
! 274: struct linux_flock *lfp;
! 275: struct flock *bfp;
! 276: {
! 277:
! 278: bfp->l_start = lfp->l_start;
! 279: bfp->l_len = lfp->l_len;
! 280: bfp->l_pid = lfp->l_pid;
! 281: bfp->l_whence = lfp->l_whence;
! 282: switch (lfp->l_type) {
! 283: case LINUX_F_RDLCK:
! 284: bfp->l_type = F_RDLCK;
! 285: break;
! 286: case LINUX_F_UNLCK:
! 287: bfp->l_type = F_UNLCK;
! 288: break;
! 289: case LINUX_F_WRLCK:
! 290: bfp->l_type = F_WRLCK;
! 291: break;
! 292: }
! 293: }
! 294:
! 295: /*
! 296: * Most actions in the fcntl() call are straightforward; simply
! 297: * pass control to the OpenBSD system call. A few commands need
! 298: * conversions after the actual system call has done its work,
! 299: * because the flag values and lock structure are different.
! 300: */
! 301: int
! 302: linux_sys_fcntl(p, v, retval)
! 303: struct proc *p;
! 304: void *v;
! 305: register_t *retval;
! 306: {
! 307: struct linux_sys_fcntl_args /* {
! 308: syscallarg(int) fd;
! 309: syscallarg(int) cmd;
! 310: syscallarg(void *) arg;
! 311: } */ *uap = v;
! 312: int fd, cmd, error, val;
! 313: caddr_t arg, sg;
! 314: struct linux_flock lfl;
! 315: struct flock *bfp, bfl;
! 316: struct sys_fcntl_args fca;
! 317: struct filedesc *fdp;
! 318: struct file *fp;
! 319: struct vnode *vp;
! 320: struct vattr va;
! 321: long pgid;
! 322: struct pgrp *pgrp;
! 323: struct tty *tp, *(*d_tty)(dev_t);
! 324:
! 325: fd = SCARG(uap, fd);
! 326: cmd = SCARG(uap, cmd);
! 327: arg = (caddr_t) SCARG(uap, arg);
! 328:
! 329: switch (cmd) {
! 330: case LINUX_F_DUPFD:
! 331: cmd = F_DUPFD;
! 332: break;
! 333: case LINUX_F_GETFD:
! 334: cmd = F_GETFD;
! 335: break;
! 336: case LINUX_F_SETFD:
! 337: cmd = F_SETFD;
! 338: break;
! 339: case LINUX_F_GETFL:
! 340: SCARG(&fca, fd) = fd;
! 341: SCARG(&fca, cmd) = F_GETFL;
! 342: SCARG(&fca, arg) = arg;
! 343: if ((error = sys_fcntl(p, &fca, retval)))
! 344: return error;
! 345: retval[0] = bsd_to_linux_ioflags(retval[0]);
! 346: return 0;
! 347: case LINUX_F_SETFL:
! 348: val = linux_to_bsd_ioflags((int)SCARG(uap, arg));
! 349: SCARG(&fca, fd) = fd;
! 350: SCARG(&fca, cmd) = F_SETFL;
! 351: SCARG(&fca, arg) = (caddr_t) val;
! 352: return sys_fcntl(p, &fca, retval);
! 353: case LINUX_F_GETLK:
! 354: sg = stackgap_init(p->p_emul);
! 355: if ((error = copyin(arg, &lfl, sizeof lfl)))
! 356: return error;
! 357: linux_to_bsd_flock(&lfl, &bfl);
! 358: bfp = (struct flock *) stackgap_alloc(&sg, sizeof *bfp);
! 359: SCARG(&fca, fd) = fd;
! 360: SCARG(&fca, cmd) = F_GETLK;
! 361: SCARG(&fca, arg) = bfp;
! 362: if ((error = copyout(&bfl, bfp, sizeof bfl)))
! 363: return error;
! 364: if ((error = sys_fcntl(p, &fca, retval)))
! 365: return error;
! 366: if ((error = copyin(bfp, &bfl, sizeof bfl)))
! 367: return error;
! 368: bsd_to_linux_flock(&bfl, &lfl);
! 369: error = copyout(&lfl, arg, sizeof lfl);
! 370: return error;
! 371: break;
! 372: case LINUX_F_SETLK:
! 373: case LINUX_F_SETLKW:
! 374: cmd = (cmd == LINUX_F_SETLK ? F_SETLK : F_SETLKW);
! 375: if ((error = copyin(arg, &lfl, sizeof lfl)))
! 376: return error;
! 377: linux_to_bsd_flock(&lfl, &bfl);
! 378: sg = stackgap_init(p->p_emul);
! 379: bfp = (struct flock *) stackgap_alloc(&sg, sizeof *bfp);
! 380: if ((error = copyout(&bfl, bfp, sizeof bfl)))
! 381: return error;
! 382: SCARG(&fca, fd) = fd;
! 383: SCARG(&fca, cmd) = cmd;
! 384: SCARG(&fca, arg) = bfp;
! 385: return sys_fcntl(p, &fca, retval);
! 386: break;
! 387: case LINUX_F_SETOWN:
! 388: case LINUX_F_GETOWN:
! 389: /*
! 390: * We need to route around the normal fcntl() for these calls,
! 391: * since it uses TIOC{G,S}PGRP, which is too restrictive for
! 392: * Linux F_{G,S}ETOWN semantics. For sockets, this problem
! 393: * does not exist.
! 394: */
! 395: fdp = p->p_fd;
! 396: if ((fp = fd_getfile(fdp, fd)) == NULL)
! 397: return (EBADF);
! 398: if (fp->f_type == DTYPE_SOCKET) {
! 399: cmd = cmd == LINUX_F_SETOWN ? F_SETOWN : F_GETOWN;
! 400: break;
! 401: }
! 402: vp = (struct vnode *)fp->f_data;
! 403: if (vp->v_type != VCHR)
! 404: return EINVAL;
! 405: FREF(fp);
! 406: error = VOP_GETATTR(vp, &va, p->p_ucred, p);
! 407: FRELE(fp);
! 408: if (error)
! 409: return error;
! 410: d_tty = cdevsw[major(va.va_rdev)].d_tty;
! 411: if (!d_tty || (!(tp = (*d_tty)(va.va_rdev))))
! 412: return EINVAL;
! 413: if (cmd == LINUX_F_GETOWN) {
! 414: retval[0] = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
! 415: return 0;
! 416: }
! 417: if ((long)arg <= 0) {
! 418: pgid = -(long)arg;
! 419: } else {
! 420: struct proc *p1 = pfind((long)arg);
! 421: if (p1 == 0)
! 422: return (ESRCH);
! 423: pgid = (long)p1->p_pgrp->pg_id;
! 424: }
! 425: pgrp = pgfind(pgid);
! 426: if (pgrp == NULL || pgrp->pg_session != p->p_session)
! 427: return EPERM;
! 428: tp->t_pgrp = pgrp;
! 429: return 0;
! 430: default:
! 431: return EOPNOTSUPP;
! 432: }
! 433:
! 434: SCARG(&fca, fd) = fd;
! 435: SCARG(&fca, cmd) = cmd;
! 436: SCARG(&fca, arg) = arg;
! 437:
! 438: return sys_fcntl(p, &fca, retval);
! 439: }
! 440:
! 441: /*
! 442: * Convert a OpenBSD stat structure to a Linux stat structure.
! 443: * Only the order of the fields and the padding in the structure
! 444: * is different. linux_fakedev is a machine-dependent function
! 445: * which optionally converts device driver major/minor numbers
! 446: * (XXX horrible, but what can you do against code that compares
! 447: * things against constant major device numbers? sigh)
! 448: */
! 449: static void
! 450: bsd_to_linux_stat(bsp, lsp)
! 451: struct stat *bsp;
! 452: struct linux_stat *lsp;
! 453: {
! 454:
! 455: lsp->lst_dev = bsp->st_dev;
! 456: lsp->lst_ino = bsp->st_ino;
! 457: lsp->lst_mode = bsp->st_mode;
! 458: lsp->lst_nlink = bsp->st_nlink;
! 459: lsp->lst_uid = bsp->st_uid;
! 460: lsp->lst_gid = bsp->st_gid;
! 461: lsp->lst_rdev = linux_fakedev(bsp->st_rdev);
! 462: lsp->lst_size = bsp->st_size;
! 463: lsp->lst_blksize = bsp->st_blksize;
! 464: lsp->lst_blocks = bsp->st_blocks;
! 465: lsp->lst_atime = bsp->st_atime;
! 466: lsp->lst_mtime = bsp->st_mtime;
! 467: lsp->lst_ctime = bsp->st_ctime;
! 468: }
! 469:
! 470: /*
! 471: * The stat functions below are plain sailing. stat and lstat are handled
! 472: * by one function to avoid code duplication.
! 473: */
! 474: int
! 475: linux_sys_fstat(p, v, retval)
! 476: struct proc *p;
! 477: void *v;
! 478: register_t *retval;
! 479: {
! 480: struct linux_sys_fstat_args /* {
! 481: syscallarg(int) fd;
! 482: syscallarg(linux_stat *) sp;
! 483: } */ *uap = v;
! 484: struct sys_fstat_args fsa;
! 485: struct linux_stat tmplst;
! 486: struct stat *st,tmpst;
! 487: caddr_t sg;
! 488: int error;
! 489:
! 490: sg = stackgap_init(p->p_emul);
! 491:
! 492: st = stackgap_alloc(&sg, sizeof (struct stat));
! 493:
! 494: SCARG(&fsa, fd) = SCARG(uap, fd);
! 495: SCARG(&fsa, sb) = st;
! 496:
! 497: if ((error = sys_fstat(p, &fsa, retval)))
! 498: return error;
! 499:
! 500: if ((error = copyin(st, &tmpst, sizeof tmpst)))
! 501: return error;
! 502:
! 503: bsd_to_linux_stat(&tmpst, &tmplst);
! 504:
! 505: if ((error = copyout(&tmplst, SCARG(uap, sp), sizeof tmplst)))
! 506: return error;
! 507:
! 508: return 0;
! 509: }
! 510:
! 511: static int
! 512: linux_stat1(p, v, retval, dolstat)
! 513: struct proc *p;
! 514: void *v;
! 515: register_t *retval;
! 516: int dolstat;
! 517: {
! 518: struct sys_stat_args sa;
! 519: struct linux_stat tmplst;
! 520: struct stat *st, tmpst;
! 521: caddr_t sg;
! 522: int error;
! 523: struct linux_sys_stat_args *uap = v;
! 524:
! 525: sg = stackgap_init(p->p_emul);
! 526:
! 527: st = stackgap_alloc(&sg, sizeof (struct stat));
! 528: LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 529:
! 530: SCARG(&sa, ub) = st;
! 531: SCARG(&sa, path) = SCARG(uap, path);
! 532:
! 533: if ((error = (dolstat ? sys_lstat(p, &sa, retval) :
! 534: sys_stat(p, &sa, retval))))
! 535: return error;
! 536:
! 537: if ((error = copyin(st, &tmpst, sizeof tmpst)))
! 538: return error;
! 539:
! 540: bsd_to_linux_stat(&tmpst, &tmplst);
! 541:
! 542: if ((error = copyout(&tmplst, SCARG(uap, sp), sizeof tmplst)))
! 543: return error;
! 544:
! 545: return 0;
! 546: }
! 547:
! 548: int
! 549: linux_sys_stat(p, v, retval)
! 550: struct proc *p;
! 551: void *v;
! 552: register_t *retval;
! 553: {
! 554: struct linux_sys_stat_args /* {
! 555: syscallarg(char *) path;
! 556: syscallarg(struct linux_stat *) sp;
! 557: } */ *uap = v;
! 558:
! 559: return linux_stat1(p, uap, retval, 0);
! 560: }
! 561:
! 562: int
! 563: linux_sys_lstat(p, v, retval)
! 564: struct proc *p;
! 565: void *v;
! 566: register_t *retval;
! 567: {
! 568: struct linux_sys_lstat_args /* {
! 569: syscallarg(char *) path;
! 570: syscallarg(struct linux_stat *) sp;
! 571: } */ *uap = v;
! 572:
! 573: return linux_stat1(p, uap, retval, 1);
! 574: }
! 575:
! 576: /*
! 577: * The following syscalls are mostly here because of the alternate path check.
! 578: */
! 579: int
! 580: linux_sys_access(p, v, retval)
! 581: struct proc *p;
! 582: void *v;
! 583: register_t *retval;
! 584: {
! 585: struct linux_sys_access_args /* {
! 586: syscallarg(char *) path;
! 587: syscallarg(int) flags;
! 588: } */ *uap = v;
! 589: caddr_t sg = stackgap_init(p->p_emul);
! 590:
! 591: LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 592:
! 593: return sys_access(p, uap, retval);
! 594: }
! 595:
! 596: int
! 597: linux_sys_unlink(p, v, retval)
! 598: struct proc *p;
! 599: void *v;
! 600: register_t *retval;
! 601:
! 602: {
! 603: struct linux_sys_unlink_args /* {
! 604: syscallarg(char *) path;
! 605: } */ *uap = v;
! 606: caddr_t sg = stackgap_init(p->p_emul);
! 607:
! 608: LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 609:
! 610: return sys_unlink(p, uap, retval);
! 611: }
! 612:
! 613: int
! 614: linux_sys_chdir(p, v, retval)
! 615: struct proc *p;
! 616: void *v;
! 617: register_t *retval;
! 618: {
! 619: struct linux_sys_chdir_args /* {
! 620: syscallarg(char *) path;
! 621: } */ *uap = v;
! 622: caddr_t sg = stackgap_init(p->p_emul);
! 623:
! 624: LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 625:
! 626: return sys_chdir(p, uap, retval);
! 627: }
! 628:
! 629: int
! 630: linux_sys_mknod(p, v, retval)
! 631: struct proc *p;
! 632: void *v;
! 633: register_t *retval;
! 634: {
! 635: struct linux_sys_mknod_args /* {
! 636: syscallarg(char *) path;
! 637: syscallarg(int) mode;
! 638: syscallarg(int) dev;
! 639: } */ *uap = v;
! 640: caddr_t sg = stackgap_init(p->p_emul);
! 641: struct sys_mkfifo_args bma;
! 642:
! 643: LINUX_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
! 644:
! 645: /*
! 646: * BSD handles FIFOs separately
! 647: */
! 648: if (S_ISFIFO(SCARG(uap, mode))) {
! 649: SCARG(&bma, path) = SCARG(uap, path);
! 650: SCARG(&bma, mode) = SCARG(uap, mode);
! 651: return sys_mkfifo(p, uap, retval);
! 652: } else
! 653: return sys_mknod(p, uap, retval);
! 654: }
! 655:
! 656: int
! 657: linux_sys_chmod(p, v, retval)
! 658: struct proc *p;
! 659: void *v;
! 660: register_t *retval;
! 661: {
! 662: struct linux_sys_chmod_args /* {
! 663: syscallarg(char *) path;
! 664: syscallarg(int) mode;
! 665: } */ *uap = v;
! 666: caddr_t sg = stackgap_init(p->p_emul);
! 667:
! 668: LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 669:
! 670: return sys_chmod(p, uap, retval);
! 671: }
! 672:
! 673: int
! 674: linux_sys_chown16(p, v, retval)
! 675: struct proc *p;
! 676: void *v;
! 677: register_t *retval;
! 678: {
! 679: struct linux_sys_chown16_args /* {
! 680: syscallarg(char *) path;
! 681: syscallarg(int) uid;
! 682: syscallarg(int) gid;
! 683: } */ *uap = v;
! 684: struct sys_chown_args bca;
! 685: caddr_t sg = stackgap_init(p->p_emul);
! 686:
! 687: LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 688:
! 689: SCARG(&bca, path) = SCARG(uap, path);
! 690: SCARG(&bca, uid) = ((linux_uid_t)SCARG(uap, uid) == (linux_uid_t)-1) ?
! 691: (uid_t)-1 : SCARG(uap, uid);
! 692: SCARG(&bca, gid) = ((linux_gid_t)SCARG(uap, gid) == (linux_gid_t)-1) ?
! 693: (gid_t)-1 : SCARG(uap, gid);
! 694:
! 695: return sys_chown(p, &bca, retval);
! 696: }
! 697:
! 698: int
! 699: linux_sys_fchown16(p, v, retval)
! 700: struct proc *p;
! 701: void *v;
! 702: register_t *retval;
! 703: {
! 704: struct linux_sys_fchown16_args /* {
! 705: syscallarg(int) fd;
! 706: syscallarg(int) uid;
! 707: syscallarg(int) gid;
! 708: } */ *uap = v;
! 709: struct sys_fchown_args bfa;
! 710:
! 711: SCARG(&bfa, fd) = SCARG(uap, fd);
! 712: SCARG(&bfa, uid) = ((linux_uid_t)SCARG(uap, uid) == (linux_uid_t)-1) ?
! 713: (uid_t)-1 : SCARG(uap, uid);
! 714: SCARG(&bfa, gid) = ((linux_gid_t)SCARG(uap, gid) == (linux_gid_t)-1) ?
! 715: (gid_t)-1 : SCARG(uap, gid);
! 716:
! 717: return sys_fchown(p, &bfa, retval);
! 718: }
! 719:
! 720: int
! 721: linux_sys_lchown16(p, v, retval)
! 722: struct proc *p;
! 723: void *v;
! 724: register_t *retval;
! 725: {
! 726: struct linux_sys_lchown16_args /* {
! 727: syscallarg(char *) path;
! 728: syscallarg(int) uid;
! 729: syscallarg(int) gid;
! 730: } */ *uap = v;
! 731: struct sys_lchown_args bla;
! 732:
! 733: SCARG(&bla, path) = SCARG(uap, path);
! 734: SCARG(&bla, uid) = ((linux_uid_t)SCARG(uap, uid) == (linux_uid_t)-1) ?
! 735: (uid_t)-1 : SCARG(uap, uid);
! 736: SCARG(&bla, gid) = ((linux_gid_t)SCARG(uap, gid) == (linux_gid_t)-1) ?
! 737: (gid_t)-1 : SCARG(uap, gid);
! 738:
! 739: return sys_lchown(p, &bla, retval);
! 740: }
! 741:
! 742: int
! 743: linux_sys_rename(p, v, retval)
! 744: struct proc *p;
! 745: void *v;
! 746: register_t *retval;
! 747: {
! 748: struct linux_sys_rename_args /* {
! 749: syscallarg(char *) from;
! 750: syscallarg(char *) to;
! 751: } */ *uap = v;
! 752: caddr_t sg = stackgap_init(p->p_emul);
! 753:
! 754: LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, from));
! 755: LINUX_CHECK_ALT_CREAT(p, &sg, SCARG(uap, to));
! 756:
! 757: return sys_rename(p, uap, retval);
! 758: }
! 759:
! 760: int
! 761: linux_sys_mkdir(p, v, retval)
! 762: struct proc *p;
! 763: void *v;
! 764: register_t *retval;
! 765: {
! 766: struct linux_sys_mkdir_args /* {
! 767: syscallarg(char *) path;
! 768: syscallarg(int) mode;
! 769: } */ *uap = v;
! 770: caddr_t sg = stackgap_init(p->p_emul);
! 771:
! 772: LINUX_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
! 773:
! 774: return sys_mkdir(p, uap, retval);
! 775: }
! 776:
! 777: int
! 778: linux_sys_rmdir(p, v, retval)
! 779: struct proc *p;
! 780: void *v;
! 781: register_t *retval;
! 782: {
! 783: struct linux_sys_rmdir_args /* {
! 784: syscallarg(char *) path;
! 785: } */ *uap = v;
! 786: caddr_t sg = stackgap_init(p->p_emul);
! 787:
! 788: LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 789:
! 790: return sys_rmdir(p, uap, retval);
! 791: }
! 792:
! 793: int
! 794: linux_sys_symlink(p, v, retval)
! 795: struct proc *p;
! 796: void *v;
! 797: register_t *retval;
! 798: {
! 799: struct linux_sys_symlink_args /* {
! 800: syscallarg(char *) path;
! 801: syscallarg(char *) to;
! 802: } */ *uap = v;
! 803: caddr_t sg = stackgap_init(p->p_emul);
! 804:
! 805: LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 806: LINUX_CHECK_ALT_CREAT(p, &sg, SCARG(uap, to));
! 807:
! 808: return sys_symlink(p, uap, retval);
! 809: }
! 810:
! 811: int
! 812: linux_sys_readlink(p, v, retval)
! 813: struct proc *p;
! 814: void *v;
! 815: register_t *retval;
! 816: {
! 817: struct linux_sys_readlink_args /* {
! 818: syscallarg(char *) name;
! 819: syscallarg(char *) buf;
! 820: syscallarg(int) count;
! 821: } */ *uap = v;
! 822: caddr_t sg = stackgap_init(p->p_emul);
! 823:
! 824: LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, name));
! 825:
! 826: return sys_readlink(p, uap, retval);
! 827: }
! 828:
! 829: int
! 830: linux_sys_truncate(p, v, retval)
! 831: struct proc *p;
! 832: void *v;
! 833: register_t *retval;
! 834: {
! 835: struct linux_sys_truncate_args /* {
! 836: syscallarg(char *) path;
! 837: syscallarg(long) length;
! 838: } */ *uap = v;
! 839: caddr_t sg = stackgap_init(p->p_emul);
! 840:
! 841: LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 842:
! 843: return compat_43_sys_truncate(p, uap, retval);
! 844: }
! 845:
! 846: /*
! 847: * This is just fsync() for now (just as it is in the Linux kernel)
! 848: */
! 849: int
! 850: linux_sys_fdatasync(p, v, retval)
! 851: struct proc *p;
! 852: void *v;
! 853: register_t *retval;
! 854: {
! 855: struct linux_sys_fdatasync_args /* {
! 856: syscallarg(int) fd;
! 857: } */ *uap = v;
! 858: return sys_fsync(p, uap, retval);
! 859: }
! 860:
! 861: /*
! 862: * pread(2).
! 863: */
! 864: int
! 865: linux_sys_pread(p, v, retval)
! 866: struct proc *p;
! 867: void *v;
! 868: register_t *retval;
! 869: {
! 870: struct linux_sys_pread_args /* {
! 871: syscallarg(int) fd;
! 872: syscallarg(void *) buf;
! 873: syscallarg(size_t) nbyte;
! 874: syscallarg(linux_off_t) offset;
! 875: } */ *uap = v;
! 876: struct sys_pread_args pra;
! 877:
! 878: SCARG(&pra, fd) = SCARG(uap, fd);
! 879: SCARG(&pra, buf) = SCARG(uap, buf);
! 880: SCARG(&pra, nbyte) = SCARG(uap, nbyte);
! 881: SCARG(&pra, offset) = SCARG(uap, offset);
! 882:
! 883: return sys_pread(p, &pra, retval);
! 884: }
! 885:
! 886: /*
! 887: * pwrite(2).
! 888: */
! 889: int
! 890: linux_sys_pwrite(p, v, retval)
! 891: struct proc *p;
! 892: void *v;
! 893: register_t *retval;
! 894: {
! 895: struct linux_sys_pwrite_args /* {
! 896: syscallarg(int) fd;
! 897: syscallarg(char *) buf;
! 898: syscallarg(size_t) nbyte;
! 899: syscallarg(linux_off_t) offset;
! 900: } */ *uap = v;
! 901: struct sys_pwrite_args pra;
! 902:
! 903: SCARG(&pra, fd) = SCARG(uap, fd);
! 904: SCARG(&pra, buf) = SCARG(uap, buf);
! 905: SCARG(&pra, nbyte) = SCARG(uap, nbyte);
! 906: SCARG(&pra, offset) = SCARG(uap, offset);
! 907:
! 908: return sys_pwrite(p, &pra, retval);
! 909: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to linux_file.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / linux