The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/compat/linux/linux_file.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1994-1995 Søren Schmidt
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer
   10  *    in this position and unchanged.
   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. The name of the author may not be used to endorse or promote products
   15  *    derived from this software without specific prior written permission
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   27  */
   28 
   29 #include <sys/cdefs.h>
   30 __FBSDID("$FreeBSD: releng/6.4/sys/compat/linux/linux_file.c 179139 2008-05-20 07:55:03Z dfr $");
   31 
   32 #include "opt_compat.h"
   33 #include "opt_mac.h"
   34 
   35 #include <sys/param.h>
   36 #include <sys/systm.h>
   37 #include <sys/conf.h>
   38 #include <sys/dirent.h>
   39 #include <sys/fcntl.h>
   40 #include <sys/file.h>
   41 #include <sys/filedesc.h>
   42 #include <sys/lock.h>
   43 #include <sys/mac.h>
   44 #include <sys/malloc.h>
   45 #include <sys/mount.h>
   46 #include <sys/mutex.h>
   47 #include <sys/proc.h>
   48 #include <sys/stat.h>
   49 #include <sys/syscallsubr.h>
   50 #include <sys/sysproto.h>
   51 #include <sys/unistd.h>
   52 #include <sys/tty.h>
   53 #include <sys/vnode.h>
   54 
   55 #include <ufs/ufs/extattr.h>
   56 #include <ufs/ufs/quota.h>
   57 #include <ufs/ufs/ufsmount.h>
   58 
   59 #include "opt_compat.h"
   60 
   61 #ifdef COMPAT_LINUX32
   62 #include <machine/../linux32/linux.h>
   63 #include <machine/../linux32/linux32_proto.h>
   64 #else
   65 #include <machine/../linux/linux.h>
   66 #include <machine/../linux/linux_proto.h>
   67 #endif
   68 #include <compat/linux/linux_util.h>
   69 
   70 #ifndef __alpha__
   71 int
   72 linux_creat(struct thread *td, struct linux_creat_args *args)
   73 {
   74     char *path;
   75     int error;
   76 
   77     LCONVPATHEXIST(td, args->path, &path);
   78 
   79 #ifdef DEBUG
   80         if (ldebug(creat))
   81                 printf(ARGS(creat, "%s, %d"), path, args->mode);
   82 #endif
   83     error = kern_open(td, path, UIO_SYSSPACE, O_WRONLY | O_CREAT | O_TRUNC,
   84         args->mode);
   85     LFREEPATH(path);
   86     return (error);
   87 }
   88 #endif /*!__alpha__*/
   89 
   90 int
   91 linux_open(struct thread *td, struct linux_open_args *args)
   92 {
   93     struct proc *p = td->td_proc;
   94     char *path;
   95     int bsd_flags, error;
   96 
   97     if (args->flags & LINUX_O_CREAT)
   98         LCONVPATHCREAT(td, args->path, &path);
   99     else
  100         LCONVPATHEXIST(td, args->path, &path);
  101 
  102 #ifdef DEBUG
  103         if (ldebug(open))
  104                 printf(ARGS(open, "%s, 0x%x, 0x%x"),
  105                     path, args->flags, args->mode);
  106 #endif
  107     bsd_flags = 0;
  108     if (args->flags & LINUX_O_RDONLY)
  109         bsd_flags |= O_RDONLY;
  110     if (args->flags & LINUX_O_WRONLY)
  111         bsd_flags |= O_WRONLY;
  112     if (args->flags & LINUX_O_RDWR)
  113         bsd_flags |= O_RDWR;
  114     if (args->flags & LINUX_O_NDELAY)
  115         bsd_flags |= O_NONBLOCK;
  116     if (args->flags & LINUX_O_APPEND)
  117         bsd_flags |= O_APPEND;
  118     if (args->flags & LINUX_O_SYNC)
  119         bsd_flags |= O_FSYNC;
  120     if (args->flags & LINUX_O_NONBLOCK)
  121         bsd_flags |= O_NONBLOCK;
  122     if (args->flags & LINUX_FASYNC)
  123         bsd_flags |= O_ASYNC;
  124     if (args->flags & LINUX_O_CREAT)
  125         bsd_flags |= O_CREAT;
  126     if (args->flags & LINUX_O_TRUNC)
  127         bsd_flags |= O_TRUNC;
  128     if (args->flags & LINUX_O_EXCL)
  129         bsd_flags |= O_EXCL;
  130     if (args->flags & LINUX_O_NOCTTY)
  131         bsd_flags |= O_NOCTTY;
  132 
  133     error = kern_open(td, path, UIO_SYSSPACE, bsd_flags, args->mode);
  134     PROC_LOCK(p);
  135     if (!error && !(bsd_flags & O_NOCTTY) &&
  136         SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) {
  137         struct file *fp;
  138 
  139         PROC_UNLOCK(p);
  140         error = fget(td, td->td_retval[0], &fp);
  141         if (!error) {
  142                 if (fp->f_type == DTYPE_VNODE)
  143                         fo_ioctl(fp, TIOCSCTTY, (caddr_t) 0, td->td_ucred,
  144                             td);
  145             fdrop(fp, td);
  146         }
  147     } else {
  148         PROC_UNLOCK(p);
  149 #ifdef DEBUG
  150         if (ldebug(open))
  151                 printf(LMSG("open returns error %d"), error);
  152 #endif
  153     }
  154     LFREEPATH(path);
  155     return error;
  156 }
  157 
  158 int
  159 linux_lseek(struct thread *td, struct linux_lseek_args *args)
  160 {
  161 
  162     struct lseek_args /* {
  163         int fd;
  164         int pad;
  165         off_t offset;
  166         int whence;
  167     } */ tmp_args;
  168     int error;
  169 
  170 #ifdef DEBUG
  171         if (ldebug(lseek))
  172                 printf(ARGS(lseek, "%d, %ld, %d"),
  173                     args->fdes, (long)args->off, args->whence);
  174 #endif
  175     tmp_args.fd = args->fdes;
  176     tmp_args.offset = (off_t)args->off;
  177     tmp_args.whence = args->whence;
  178     error = lseek(td, &tmp_args);
  179     return error;
  180 }
  181 
  182 #ifndef __alpha__
  183 int
  184 linux_llseek(struct thread *td, struct linux_llseek_args *args)
  185 {
  186         struct lseek_args bsd_args;
  187         int error;
  188         off_t off;
  189 
  190 #ifdef DEBUG
  191         if (ldebug(llseek))
  192                 printf(ARGS(llseek, "%d, %d:%d, %d"),
  193                     args->fd, args->ohigh, args->olow, args->whence);
  194 #endif
  195         off = (args->olow) | (((off_t) args->ohigh) << 32);
  196 
  197         bsd_args.fd = args->fd;
  198         bsd_args.offset = off;
  199         bsd_args.whence = args->whence;
  200 
  201         if ((error = lseek(td, &bsd_args)))
  202                 return error;
  203 
  204         if ((error = copyout(td->td_retval, args->res, sizeof (off_t))))
  205                 return error;
  206 
  207         td->td_retval[0] = 0;
  208         return 0;
  209 }
  210 #endif /*!__alpha__*/
  211 
  212 #ifndef __alpha__
  213 int
  214 linux_readdir(struct thread *td, struct linux_readdir_args *args)
  215 {
  216         struct linux_getdents_args lda;
  217 
  218         lda.fd = args->fd;
  219         lda.dent = args->dent;
  220         lda.count = 1;
  221         return linux_getdents(td, &lda);
  222 }
  223 #endif /*!__alpha__*/
  224 
  225 /*
  226  * Note that linux_getdents(2) and linux_getdents64(2) have the same
  227  * arguments. They only differ in the definition of struct dirent they
  228  * operate on. We use this to common the code, with the exception of
  229  * accessing struct dirent. Note that linux_readdir(2) is implemented
  230  * by means of linux_getdents(2). In this case we never operate on
  231  * struct dirent64 and thus don't need to handle it...
  232  */
  233 
  234 struct l_dirent {
  235         l_long          d_ino;
  236         l_off_t         d_off;
  237         l_ushort        d_reclen;
  238         char            d_name[LINUX_NAME_MAX + 1];
  239 };
  240 
  241 struct l_dirent64 {
  242         uint64_t        d_ino;
  243         int64_t         d_off;
  244         l_ushort        d_reclen;
  245         u_char          d_type;
  246         char            d_name[LINUX_NAME_MAX + 1];
  247 };
  248 
  249 #define LINUX_RECLEN(de,namlen) \
  250     ALIGN((((char *)&(de)->d_name - (char *)de) + (namlen) + 1))
  251 
  252 #define LINUX_DIRBLKSIZ         512
  253 
  254 static int
  255 getdents_common(struct thread *td, struct linux_getdents64_args *args,
  256     int is64bit)
  257 {
  258         struct dirent *bdp;
  259         struct vnode *vp;
  260         caddr_t inp, buf;               /* BSD-format */
  261         int len, reclen;                /* BSD-format */
  262         caddr_t outp;                   /* Linux-format */
  263         int resid, linuxreclen=0;       /* Linux-format */
  264         struct file *fp;
  265         struct uio auio;
  266         struct iovec aiov;
  267         off_t off;
  268         struct l_dirent linux_dirent;
  269         struct l_dirent64 linux_dirent64;
  270         int buflen, error, eofflag, nbytes, justone;
  271         u_long *cookies = NULL, *cookiep;
  272         int ncookies, vfslocked;
  273 
  274         nbytes = args->count;
  275         if (nbytes == 1) {
  276                 /* readdir(2) case. Always struct dirent. */
  277                 if (is64bit)
  278                         return (EINVAL);
  279                 nbytes = sizeof(linux_dirent);
  280                 justone = 1;
  281         } else
  282                 justone = 0;
  283 
  284         if ((error = getvnode(td->td_proc->p_fd, args->fd, &fp)) != 0)
  285                 return (error);
  286 
  287         if ((fp->f_flag & FREAD) == 0) {
  288                 fdrop(fp, td);
  289                 return (EBADF);
  290         }
  291 
  292         vp = fp->f_vnode;
  293         vfslocked = VFS_LOCK_GIANT(vp->v_mount);
  294         if (vp->v_type != VDIR) {
  295                 VFS_UNLOCK_GIANT(vfslocked);
  296                 fdrop(fp, td);
  297                 return (EINVAL);
  298         }
  299 
  300         off = fp->f_offset;
  301 
  302         buflen = max(LINUX_DIRBLKSIZ, nbytes);
  303         buflen = min(buflen, MAXBSIZE);
  304         buf = malloc(buflen, M_TEMP, M_WAITOK);
  305         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
  306 
  307 again:
  308         aiov.iov_base = buf;
  309         aiov.iov_len = buflen;
  310         auio.uio_iov = &aiov;
  311         auio.uio_iovcnt = 1;
  312         auio.uio_rw = UIO_READ;
  313         auio.uio_segflg = UIO_SYSSPACE;
  314         auio.uio_td = td;
  315         auio.uio_resid = buflen;
  316         auio.uio_offset = off;
  317 
  318         if (cookies) {
  319                 free(cookies, M_TEMP);
  320                 cookies = NULL;
  321         }
  322 
  323 #ifdef MAC
  324         /*
  325          * Do directory search MAC check using non-cached credentials.
  326          */
  327         if ((error = mac_check_vnode_readdir(td->td_ucred, vp)))
  328                 goto out;
  329 #endif /* MAC */
  330         if ((error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, &ncookies,
  331                  &cookies)))
  332                 goto out;
  333 
  334         inp = buf;
  335         outp = (caddr_t)args->dirent;
  336         resid = nbytes;
  337         if ((len = buflen - auio.uio_resid) <= 0)
  338                 goto eof;
  339 
  340         cookiep = cookies;
  341 
  342         if (cookies) {
  343                 /*
  344                  * When using cookies, the vfs has the option of reading from
  345                  * a different offset than that supplied (UFS truncates the
  346                  * offset to a block boundary to make sure that it never reads
  347                  * partway through a directory entry, even if the directory
  348                  * has been compacted).
  349                  */
  350                 while (len > 0 && ncookies > 0 && *cookiep <= off) {
  351                         bdp = (struct dirent *) inp;
  352                         len -= bdp->d_reclen;
  353                         inp += bdp->d_reclen;
  354                         cookiep++;
  355                         ncookies--;
  356                 }
  357         }
  358 
  359         while (len > 0) {
  360                 if (cookiep && ncookies == 0)
  361                         break;
  362                 bdp = (struct dirent *) inp;
  363                 reclen = bdp->d_reclen;
  364                 if (reclen & 3) {
  365                         error = EFAULT;
  366                         goto out;
  367                 }
  368 
  369                 if (bdp->d_fileno == 0) {
  370                         inp += reclen;
  371                         if (cookiep) {
  372                                 off = *cookiep++;
  373                                 ncookies--;
  374                         } else
  375                                 off += reclen;
  376 
  377                         len -= reclen;
  378                         continue;
  379                 }
  380 
  381                 linuxreclen = (is64bit)
  382                     ? LINUX_RECLEN(&linux_dirent64, bdp->d_namlen)
  383                     : LINUX_RECLEN(&linux_dirent, bdp->d_namlen);
  384 
  385                 if (reclen > len || resid < linuxreclen) {
  386                         outp++;
  387                         break;
  388                 }
  389 
  390                 if (justone) {
  391                         /* readdir(2) case. */
  392                         linux_dirent.d_ino = (l_long)bdp->d_fileno;
  393                         linux_dirent.d_off = (l_off_t)linuxreclen;
  394                         linux_dirent.d_reclen = (l_ushort)bdp->d_namlen;
  395                         strcpy(linux_dirent.d_name, bdp->d_name);
  396                         error = copyout(&linux_dirent, outp, linuxreclen);
  397                 } else {
  398                         if (is64bit) {
  399                                 linux_dirent64.d_ino = bdp->d_fileno;
  400                                 linux_dirent64.d_off = (cookiep)
  401                                     ? (l_off_t)*cookiep
  402                                     : (l_off_t)(off + reclen);
  403                                 linux_dirent64.d_reclen =
  404                                     (l_ushort)linuxreclen;
  405                                 linux_dirent64.d_type = bdp->d_type;
  406                                 strcpy(linux_dirent64.d_name, bdp->d_name);
  407                                 error = copyout(&linux_dirent64, outp,
  408                                     linuxreclen);
  409                         } else {
  410                                 linux_dirent.d_ino = bdp->d_fileno;
  411                                 linux_dirent.d_off = (cookiep)
  412                                     ? (l_off_t)*cookiep
  413                                     : (l_off_t)(off + reclen);
  414                                 linux_dirent.d_reclen = (l_ushort)linuxreclen;
  415                                 strcpy(linux_dirent.d_name, bdp->d_name);
  416                                 error = copyout(&linux_dirent, outp,
  417                                     linuxreclen);
  418                         }
  419                 }
  420                 if (error)
  421                         goto out;
  422 
  423                 inp += reclen;
  424                 if (cookiep) {
  425                         off = *cookiep++;
  426                         ncookies--;
  427                 } else
  428                         off += reclen;
  429 
  430                 outp += linuxreclen;
  431                 resid -= linuxreclen;
  432                 len -= reclen;
  433                 if (justone)
  434                         break;
  435         }
  436 
  437         if (outp == (caddr_t)args->dirent)
  438                 goto again;
  439 
  440         fp->f_offset = off;
  441         if (justone)
  442                 nbytes = resid + linuxreclen;
  443 
  444 eof:
  445         td->td_retval[0] = nbytes - resid;
  446 
  447 out:
  448         if (cookies)
  449                 free(cookies, M_TEMP);
  450 
  451         VOP_UNLOCK(vp, 0, td);
  452         VFS_UNLOCK_GIANT(vfslocked);
  453         fdrop(fp, td);
  454         free(buf, M_TEMP);
  455         return (error);
  456 }
  457 
  458 int
  459 linux_getdents(struct thread *td, struct linux_getdents_args *args)
  460 {
  461 
  462 #ifdef DEBUG
  463         if (ldebug(getdents))
  464                 printf(ARGS(getdents, "%d, *, %d"), args->fd, args->count);
  465 #endif
  466 
  467         return (getdents_common(td, (struct linux_getdents64_args*)args, 0));
  468 }
  469 
  470 int
  471 linux_getdents64(struct thread *td, struct linux_getdents64_args *args)
  472 {
  473 
  474 #ifdef DEBUG
  475         if (ldebug(getdents64))
  476                 printf(ARGS(getdents64, "%d, *, %d"), args->fd, args->count);
  477 #endif
  478 
  479         return (getdents_common(td, args, 1));
  480 }
  481 
  482 /*
  483  * These exist mainly for hooks for doing /compat/linux translation.
  484  */
  485 
  486 int
  487 linux_access(struct thread *td, struct linux_access_args *args)
  488 {
  489         char *path;
  490         int error;
  491 
  492         /* linux convention */
  493         if (args->flags & ~(F_OK | X_OK | W_OK | R_OK))
  494                 return (EINVAL);
  495 
  496         LCONVPATHEXIST(td, args->path, &path);
  497 
  498 #ifdef DEBUG
  499         if (ldebug(access))
  500                 printf(ARGS(access, "%s, %d"), path, args->flags);
  501 #endif
  502         error = kern_access(td, path, UIO_SYSSPACE, args->flags);
  503         LFREEPATH(path);
  504 
  505         return (error);
  506 }
  507 
  508 int
  509 linux_unlink(struct thread *td, struct linux_unlink_args *args)
  510 {
  511         char *path;
  512         int error;
  513         struct stat st;
  514 
  515         LCONVPATHEXIST(td, args->path, &path);
  516 
  517 #ifdef DEBUG
  518         if (ldebug(unlink))
  519                 printf(ARGS(unlink, "%s"), path);
  520 #endif
  521 
  522         error = kern_unlink(td, path, UIO_SYSSPACE);
  523         if (error == EPERM)
  524                 /* Introduce POSIX noncompliant behaviour of Linux */
  525                 if (kern_stat(td, path, UIO_SYSSPACE, &st) == 0)
  526                         if (S_ISDIR(st.st_mode))
  527                                 error = EISDIR;
  528         LFREEPATH(path);
  529         return (error);
  530 }
  531 
  532 int
  533 linux_chdir(struct thread *td, struct linux_chdir_args *args)
  534 {
  535         char *path;
  536         int error;
  537 
  538         LCONVPATHEXIST(td, args->path, &path);
  539 
  540 #ifdef DEBUG
  541         if (ldebug(chdir))
  542                 printf(ARGS(chdir, "%s"), path);
  543 #endif
  544         error = kern_chdir(td, path, UIO_SYSSPACE);
  545         LFREEPATH(path);
  546         return (error);
  547 }
  548 
  549 int
  550 linux_chmod(struct thread *td, struct linux_chmod_args *args)
  551 {
  552         char *path;
  553         int error;
  554 
  555         LCONVPATHEXIST(td, args->path, &path);
  556 
  557 #ifdef DEBUG
  558         if (ldebug(chmod))
  559                 printf(ARGS(chmod, "%s, %d"), path, args->mode);
  560 #endif
  561         error = kern_chmod(td, path, UIO_SYSSPACE, args->mode);
  562         LFREEPATH(path);
  563         return (error);
  564 }
  565 
  566 int
  567 linux_mkdir(struct thread *td, struct linux_mkdir_args *args)
  568 {
  569         char *path;
  570         int error;
  571 
  572         LCONVPATHCREAT(td, args->path, &path);
  573 
  574 #ifdef DEBUG
  575         if (ldebug(mkdir))
  576                 printf(ARGS(mkdir, "%s, %d"), path, args->mode);
  577 #endif
  578         error = kern_mkdir(td, path, UIO_SYSSPACE, args->mode);
  579         LFREEPATH(path);
  580         return (error);
  581 }
  582 
  583 int
  584 linux_rmdir(struct thread *td, struct linux_rmdir_args *args)
  585 {
  586         char *path;
  587         int error;
  588 
  589         LCONVPATHEXIST(td, args->path, &path);
  590 
  591 #ifdef DEBUG
  592         if (ldebug(rmdir))
  593                 printf(ARGS(rmdir, "%s"), path);
  594 #endif
  595         error = kern_rmdir(td, path, UIO_SYSSPACE);
  596         LFREEPATH(path);
  597         return (error);
  598 }
  599 
  600 int
  601 linux_rename(struct thread *td, struct linux_rename_args *args)
  602 {
  603         char *from, *to;
  604         int error;
  605 
  606         LCONVPATHEXIST(td, args->from, &from);
  607         /* Expand LCONVPATHCREATE so that `from' can be freed on errors */
  608         error = linux_emul_convpath(td, args->to, UIO_USERSPACE, &to, 1);
  609         if (to == NULL) {
  610                 LFREEPATH(from);
  611                 return (error);
  612         }
  613 
  614 #ifdef DEBUG
  615         if (ldebug(rename))
  616                 printf(ARGS(rename, "%s, %s"), from, to);
  617 #endif
  618         error = kern_rename(td, from, to, UIO_SYSSPACE);
  619         LFREEPATH(from);
  620         LFREEPATH(to);
  621         return (error);
  622 }
  623 
  624 int
  625 linux_symlink(struct thread *td, struct linux_symlink_args *args)
  626 {
  627         char *path, *to;
  628         int error;
  629 
  630         LCONVPATHEXIST(td, args->path, &path);
  631         /* Expand LCONVPATHCREATE so that `path' can be freed on errors */
  632         error = linux_emul_convpath(td, args->to, UIO_USERSPACE, &to, 1);
  633         if (to == NULL) {
  634                 LFREEPATH(path);
  635                 return (error);
  636         }
  637 
  638 #ifdef DEBUG
  639         if (ldebug(symlink))
  640                 printf(ARGS(symlink, "%s, %s"), path, to);
  641 #endif
  642         error = kern_symlink(td, path, to, UIO_SYSSPACE);
  643         LFREEPATH(path);
  644         LFREEPATH(to);
  645         return (error);
  646 }
  647 
  648 int
  649 linux_readlink(struct thread *td, struct linux_readlink_args *args)
  650 {
  651         char *name;
  652         int error;
  653 
  654         LCONVPATHEXIST(td, args->name, &name);
  655 
  656 #ifdef DEBUG
  657         if (ldebug(readlink))
  658                 printf(ARGS(readlink, "%s, %p, %d"), name, (void *)args->buf,
  659                     args->count);
  660 #endif
  661         error = kern_readlink(td, name, UIO_SYSSPACE, args->buf, UIO_USERSPACE,
  662             args->count);
  663         LFREEPATH(name);
  664         return (error);
  665 }
  666 
  667 int
  668 linux_truncate(struct thread *td, struct linux_truncate_args *args)
  669 {
  670         char *path;
  671         int error;
  672 
  673         LCONVPATHEXIST(td, args->path, &path);
  674 
  675 #ifdef DEBUG
  676         if (ldebug(truncate))
  677                 printf(ARGS(truncate, "%s, %ld"), path, (long)args->length);
  678 #endif
  679 
  680         error = kern_truncate(td, path, UIO_SYSSPACE, args->length);
  681         LFREEPATH(path);
  682         return (error);
  683 }
  684 
  685 int
  686 linux_ftruncate(struct thread *td, struct linux_ftruncate_args *args)
  687 {
  688         struct ftruncate_args /* {
  689                 int fd;
  690                 int pad;
  691                 off_t length;
  692                 } */ nuap;
  693            
  694         nuap.fd = args->fd;
  695         nuap.pad = 0;
  696         nuap.length = args->length;
  697         return (ftruncate(td, &nuap));
  698 }
  699 
  700 int
  701 linux_link(struct thread *td, struct linux_link_args *args)
  702 {
  703         char *path, *to;
  704         int error;
  705 
  706         LCONVPATHEXIST(td, args->path, &path);
  707         /* Expand LCONVPATHCREATE so that `path' can be freed on errors */
  708         error = linux_emul_convpath(td, args->to, UIO_USERSPACE, &to, 1);
  709         if (to == NULL) {
  710                 LFREEPATH(path);
  711                 return (error);
  712         }
  713 
  714 #ifdef DEBUG
  715         if (ldebug(link))
  716                 printf(ARGS(link, "%s, %s"), path, to);
  717 #endif
  718         error = kern_link(td, path, to, UIO_SYSSPACE);
  719         LFREEPATH(path);
  720         LFREEPATH(to);
  721         return (error);
  722 }
  723 
  724 #ifndef __alpha__
  725 int
  726 linux_fdatasync(td, uap)
  727         struct thread *td;
  728         struct linux_fdatasync_args *uap;
  729 {
  730         struct fsync_args bsd;
  731 
  732         bsd.fd = uap->fd;
  733         return fsync(td, &bsd);
  734 }
  735 #endif /*!__alpha__*/
  736 
  737 int
  738 linux_pread(td, uap)
  739         struct thread *td;
  740         struct linux_pread_args *uap;
  741 {
  742         struct pread_args bsd;
  743         struct vnode *vp;
  744         int error;
  745 
  746         bsd.fd = uap->fd;
  747         bsd.buf = uap->buf;
  748         bsd.nbyte = uap->nbyte;
  749         bsd.offset = uap->offset;
  750 
  751         error = pread(td, &bsd);
  752 
  753         if (error == 0) {
  754                 /* This seems to violate POSIX but linux does it */
  755                 if ((error = fgetvp(td, uap->fd, &vp)) != 0)
  756                         return (error);
  757                 if (vp->v_type == VDIR) {
  758                         vrele(vp);
  759                         return (EISDIR);
  760                 }
  761                 vrele(vp);
  762         }
  763 
  764         return (error);
  765 }
  766 
  767 int
  768 linux_pwrite(td, uap)
  769         struct thread *td;
  770         struct linux_pwrite_args *uap;
  771 {
  772         struct pwrite_args bsd;
  773 
  774         bsd.fd = uap->fd;
  775         bsd.buf = uap->buf;
  776         bsd.nbyte = uap->nbyte;
  777         bsd.offset = uap->offset;
  778         return pwrite(td, &bsd);
  779 }
  780 
  781 int
  782 linux_mount(struct thread *td, struct linux_mount_args *args)
  783 {
  784         struct ufs_args ufs;
  785         char fstypename[MFSNAMELEN];
  786         char mntonname[MNAMELEN], mntfromname[MNAMELEN];
  787         int error;
  788         int fsflags;
  789         void *fsdata;
  790 
  791         error = copyinstr(args->filesystemtype, fstypename, MFSNAMELEN - 1,
  792             NULL);
  793         if (error)
  794                 return (error);
  795         error = copyinstr(args->specialfile, mntfromname, MNAMELEN - 1, NULL);
  796         if (error)
  797                 return (error);
  798         error = copyinstr(args->dir, mntonname, MNAMELEN - 1, NULL);
  799         if (error)
  800                 return (error);
  801 
  802 #ifdef DEBUG
  803         if (ldebug(mount))
  804                 printf(ARGS(mount, "%s, %s, %s"),
  805                     fstypename, mntfromname, mntonname);
  806 #endif
  807 
  808         if (strcmp(fstypename, "ext2") == 0) {
  809                 strcpy(fstypename, "ext2fs");
  810                 fsdata = &ufs;
  811                 ufs.fspec = mntfromname;
  812 #define DEFAULT_ROOTID          -2
  813                 ufs.export.ex_root = DEFAULT_ROOTID;
  814                 ufs.export.ex_flags =
  815                     args->rwflag & LINUX_MS_RDONLY ? MNT_EXRDONLY : 0;
  816         } else if (strcmp(fstypename, "proc") == 0) {
  817                 strcpy(fstypename, "linprocfs");
  818                 fsdata = NULL;
  819         } else {
  820                 return (ENODEV);
  821         }
  822 
  823         fsflags = 0;
  824 
  825         if ((args->rwflag & 0xffff0000) == 0xc0ed0000) {
  826                 /*
  827                  * Linux SYNC flag is not included; the closest equivalent
  828                  * FreeBSD has is !ASYNC, which is our default.
  829                  */
  830                 if (args->rwflag & LINUX_MS_RDONLY)
  831                         fsflags |= MNT_RDONLY;
  832                 if (args->rwflag & LINUX_MS_NOSUID)
  833                         fsflags |= MNT_NOSUID;
  834                 if (args->rwflag & LINUX_MS_NOEXEC)
  835                         fsflags |= MNT_NOEXEC;
  836                 if (args->rwflag & LINUX_MS_REMOUNT)
  837                         fsflags |= MNT_UPDATE;
  838         }
  839 
  840         if (strcmp(fstypename, "linprocfs") == 0) {
  841                 error = kernel_vmount(fsflags,
  842                         "fstype", fstypename,
  843                         "fspath", mntonname,
  844                         NULL);
  845         } else
  846                 error = EOPNOTSUPP;
  847         return (error);
  848 }
  849 
  850 int
  851 linux_oldumount(struct thread *td, struct linux_oldumount_args *args)
  852 {
  853         struct linux_umount_args args2;
  854 
  855         args2.path = args->path;
  856         args2.flags = 0;
  857         return (linux_umount(td, &args2));
  858 }
  859 
  860 int
  861 linux_umount(struct thread *td, struct linux_umount_args *args)
  862 {
  863         struct unmount_args bsd;
  864 
  865         bsd.path = args->path;
  866         bsd.flags = args->flags;        /* XXX correct? */
  867         return (unmount(td, &bsd));
  868 }
  869 
  870 /*
  871  * fcntl family of syscalls
  872  */
  873 
  874 struct l_flock {
  875         l_short         l_type;
  876         l_short         l_whence;
  877         l_off_t         l_start;
  878         l_off_t         l_len;
  879         l_pid_t         l_pid;
  880 }
  881 #if defined(__amd64__) && defined(COMPAT_LINUX32)
  882 __packed
  883 #endif
  884 ;
  885 
  886 static void
  887 linux_to_bsd_flock(struct l_flock *linux_flock, struct flock *bsd_flock)
  888 {
  889         switch (linux_flock->l_type) {
  890         case LINUX_F_RDLCK:
  891                 bsd_flock->l_type = F_RDLCK;
  892                 break;
  893         case LINUX_F_WRLCK:
  894                 bsd_flock->l_type = F_WRLCK;
  895                 break;
  896         case LINUX_F_UNLCK:
  897                 bsd_flock->l_type = F_UNLCK;
  898                 break;
  899         default:
  900                 bsd_flock->l_type = -1;
  901                 break;
  902         }
  903         bsd_flock->l_whence = linux_flock->l_whence;
  904         bsd_flock->l_start = (off_t)linux_flock->l_start;
  905         bsd_flock->l_len = (off_t)linux_flock->l_len;
  906         bsd_flock->l_pid = (pid_t)linux_flock->l_pid;
  907 }
  908 
  909 static void
  910 bsd_to_linux_flock(struct flock *bsd_flock, struct l_flock *linux_flock)
  911 {
  912         switch (bsd_flock->l_type) {
  913         case F_RDLCK:
  914                 linux_flock->l_type = LINUX_F_RDLCK;
  915                 break;
  916         case F_WRLCK:
  917                 linux_flock->l_type = LINUX_F_WRLCK;
  918                 break;
  919         case F_UNLCK:
  920                 linux_flock->l_type = LINUX_F_UNLCK;
  921                 break;
  922         }
  923         linux_flock->l_whence = bsd_flock->l_whence;
  924         linux_flock->l_start = (l_off_t)bsd_flock->l_start;
  925         linux_flock->l_len = (l_off_t)bsd_flock->l_len;
  926         linux_flock->l_pid = (l_pid_t)bsd_flock->l_pid;
  927 }
  928 
  929 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
  930 struct l_flock64 {
  931         l_short         l_type;
  932         l_short         l_whence;
  933         l_loff_t        l_start;
  934         l_loff_t        l_len;
  935         l_pid_t         l_pid;
  936 }
  937 #if defined(__amd64__) && defined(COMPAT_LINUX32)
  938 __packed
  939 #endif
  940 ;
  941 
  942 static void
  943 linux_to_bsd_flock64(struct l_flock64 *linux_flock, struct flock *bsd_flock)
  944 {
  945         switch (linux_flock->l_type) {
  946         case LINUX_F_RDLCK:
  947                 bsd_flock->l_type = F_RDLCK;
  948                 break;
  949         case LINUX_F_WRLCK:
  950                 bsd_flock->l_type = F_WRLCK;
  951                 break;
  952         case LINUX_F_UNLCK:
  953                 bsd_flock->l_type = F_UNLCK;
  954                 break;
  955         default:
  956                 bsd_flock->l_type = -1;
  957                 break;
  958         }
  959         bsd_flock->l_whence = linux_flock->l_whence;
  960         bsd_flock->l_start = (off_t)linux_flock->l_start;
  961         bsd_flock->l_len = (off_t)linux_flock->l_len;
  962         bsd_flock->l_pid = (pid_t)linux_flock->l_pid;
  963         bsd_flock->l_sysid = 0;
  964 }
  965 
  966 static void
  967 bsd_to_linux_flock64(struct flock *bsd_flock, struct l_flock64 *linux_flock)
  968 {
  969         switch (bsd_flock->l_type) {
  970         case F_RDLCK:
  971                 linux_flock->l_type = LINUX_F_RDLCK;
  972                 break;
  973         case F_WRLCK:
  974                 linux_flock->l_type = LINUX_F_WRLCK;
  975                 break;
  976         case F_UNLCK:
  977                 linux_flock->l_type = LINUX_F_UNLCK;
  978                 break;
  979         }
  980         linux_flock->l_whence = bsd_flock->l_whence;
  981         linux_flock->l_start = (l_loff_t)bsd_flock->l_start;
  982         linux_flock->l_len = (l_loff_t)bsd_flock->l_len;
  983         linux_flock->l_pid = (l_pid_t)bsd_flock->l_pid;
  984 }
  985 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
  986 
  987 #if defined(__alpha__)
  988 #define linux_fcntl64_args      linux_fcntl_args
  989 #endif
  990 
  991 static int
  992 fcntl_common(struct thread *td, struct linux_fcntl64_args *args)
  993 {
  994         struct l_flock linux_flock;
  995         struct flock bsd_flock;
  996         struct file *fp;
  997         long arg;
  998         int error, result;
  999 
 1000         switch (args->cmd) {
 1001         case LINUX_F_DUPFD:
 1002                 return (kern_fcntl(td, args->fd, F_DUPFD, args->arg));
 1003 
 1004         case LINUX_F_GETFD:
 1005                 return (kern_fcntl(td, args->fd, F_GETFD, 0));
 1006 
 1007         case LINUX_F_SETFD:
 1008                 return (kern_fcntl(td, args->fd, F_SETFD, args->arg));
 1009 
 1010         case LINUX_F_GETFL:
 1011                 error = kern_fcntl(td, args->fd, F_GETFL, 0);
 1012                 result = td->td_retval[0];
 1013                 td->td_retval[0] = 0;
 1014                 if (result & O_RDONLY)
 1015                         td->td_retval[0] |= LINUX_O_RDONLY;
 1016                 if (result & O_WRONLY)
 1017                         td->td_retval[0] |= LINUX_O_WRONLY;
 1018                 if (result & O_RDWR)
 1019                         td->td_retval[0] |= LINUX_O_RDWR;
 1020                 if (result & O_NDELAY)
 1021                         td->td_retval[0] |= LINUX_O_NONBLOCK;
 1022                 if (result & O_APPEND)
 1023                         td->td_retval[0] |= LINUX_O_APPEND;
 1024                 if (result & O_FSYNC)
 1025                         td->td_retval[0] |= LINUX_O_SYNC;
 1026                 if (result & O_ASYNC)
 1027                         td->td_retval[0] |= LINUX_FASYNC;
 1028 #ifdef LINUX_O_NOFOLLOW
 1029                 if (result & O_NOFOLLOW)
 1030                         td->td_retval[0] |= LINUX_O_NOFOLLOW;
 1031 #endif
 1032 #ifdef LINUX_O_DIRECT
 1033                 if (result & O_DIRECT)
 1034                         td->td_retval[0] |= LINUX_O_DIRECT;
 1035 #endif
 1036                 return (error);
 1037 
 1038         case LINUX_F_SETFL:
 1039                 arg = 0;
 1040                 if (args->arg & LINUX_O_NDELAY)
 1041                         arg |= O_NONBLOCK;
 1042                 if (args->arg & LINUX_O_APPEND)
 1043                         arg |= O_APPEND;
 1044                 if (args->arg & LINUX_O_SYNC)
 1045                         arg |= O_FSYNC;
 1046                 if (args->arg & LINUX_FASYNC)
 1047                         arg |= O_ASYNC;
 1048 #ifdef LINUX_O_NOFOLLOW
 1049                 if (args->arg & LINUX_O_NOFOLLOW)
 1050                         arg |= O_NOFOLLOW;
 1051 #endif
 1052 #ifdef LINUX_O_DIRECT
 1053                 if (args->arg & LINUX_O_DIRECT)
 1054                         arg |= O_DIRECT;
 1055 #endif
 1056                 return (kern_fcntl(td, args->fd, F_SETFL, arg));
 1057 
 1058         case LINUX_F_GETLK:
 1059                 error = copyin((void *)args->arg, &linux_flock,
 1060                     sizeof(linux_flock));
 1061                 if (error)
 1062                         return (error);
 1063                 linux_to_bsd_flock(&linux_flock, &bsd_flock);
 1064                 error = kern_fcntl(td, args->fd, F_GETLK, (intptr_t)&bsd_flock);
 1065                 if (error)
 1066                         return (error);
 1067                 bsd_to_linux_flock(&bsd_flock, &linux_flock);
 1068                 return (copyout(&linux_flock, (void *)args->arg,
 1069                     sizeof(linux_flock)));
 1070 
 1071         case LINUX_F_SETLK:
 1072                 error = copyin((void *)args->arg, &linux_flock,
 1073                     sizeof(linux_flock));
 1074                 if (error)
 1075                         return (error);
 1076                 linux_to_bsd_flock(&linux_flock, &bsd_flock);
 1077                 return (kern_fcntl(td, args->fd, F_SETLK,
 1078                     (intptr_t)&bsd_flock));
 1079 
 1080         case LINUX_F_SETLKW:
 1081                 error = copyin((void *)args->arg, &linux_flock,
 1082                     sizeof(linux_flock));
 1083                 if (error)
 1084                         return (error);
 1085                 linux_to_bsd_flock(&linux_flock, &bsd_flock);
 1086                 return (kern_fcntl(td, args->fd, F_SETLKW,
 1087                      (intptr_t)&bsd_flock));
 1088 
 1089         case LINUX_F_GETOWN:
 1090                 return (kern_fcntl(td, args->fd, F_GETOWN, 0));
 1091 
 1092         case LINUX_F_SETOWN:
 1093                 /*
 1094                  * XXX some Linux applications depend on F_SETOWN having no
 1095                  * significant effect for pipes (SIGIO is not delivered for
 1096                  * pipes under Linux-2.2.35 at least).
 1097                  */
 1098                 error = fget(td, args->fd, &fp);
 1099                 if (error)
 1100                         return (error);
 1101                 if (fp->f_type == DTYPE_PIPE) {
 1102                         fdrop(fp, td);
 1103                         return (EINVAL);
 1104                 }
 1105                 fdrop(fp, td);
 1106 
 1107                 return (kern_fcntl(td, args->fd, F_SETOWN, args->arg));
 1108         }
 1109 
 1110         return (EINVAL);
 1111 }
 1112 
 1113 int
 1114 linux_fcntl(struct thread *td, struct linux_fcntl_args *args)
 1115 {
 1116         struct linux_fcntl64_args args64;
 1117 
 1118 #ifdef DEBUG
 1119         if (ldebug(fcntl))
 1120                 printf(ARGS(fcntl, "%d, %08x, *"), args->fd, args->cmd);
 1121 #endif
 1122 
 1123         args64.fd = args->fd;
 1124         args64.cmd = args->cmd;
 1125         args64.arg = args->arg;
 1126         return (fcntl_common(td, &args64));
 1127 }
 1128 
 1129 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 1130 int
 1131 linux_fcntl64(struct thread *td, struct linux_fcntl64_args *args)
 1132 {
 1133         struct l_flock64 linux_flock;
 1134         struct flock bsd_flock;
 1135         int error;
 1136 
 1137 #ifdef DEBUG
 1138         if (ldebug(fcntl64))
 1139                 printf(ARGS(fcntl64, "%d, %08x, *"), args->fd, args->cmd);
 1140 #endif
 1141 
 1142         switch (args->cmd) {
 1143         case LINUX_F_GETLK64:
 1144                 error = copyin((void *)args->arg, &linux_flock,
 1145                     sizeof(linux_flock));
 1146                 if (error)
 1147                         return (error);
 1148                 linux_to_bsd_flock64(&linux_flock, &bsd_flock);
 1149                 error = kern_fcntl(td, args->fd, F_GETLK, (intptr_t)&bsd_flock);
 1150                 if (error)
 1151                         return (error);
 1152                 bsd_to_linux_flock64(&bsd_flock, &linux_flock);
 1153                 return (copyout(&linux_flock, (void *)args->arg,
 1154                             sizeof(linux_flock)));
 1155 
 1156         case LINUX_F_SETLK64:
 1157                 error = copyin((void *)args->arg, &linux_flock,
 1158                     sizeof(linux_flock));
 1159                 if (error)
 1160                         return (error);
 1161                 linux_to_bsd_flock64(&linux_flock, &bsd_flock);
 1162                 return (kern_fcntl(td, args->fd, F_SETLK,
 1163                     (intptr_t)&bsd_flock));
 1164 
 1165         case LINUX_F_SETLKW64:
 1166                 error = copyin((void *)args->arg, &linux_flock,
 1167                     sizeof(linux_flock));
 1168                 if (error)
 1169                         return (error);
 1170                 linux_to_bsd_flock64(&linux_flock, &bsd_flock);
 1171                 return (kern_fcntl(td, args->fd, F_SETLKW,
 1172                     (intptr_t)&bsd_flock));
 1173         }
 1174 
 1175         return (fcntl_common(td, args));
 1176 }
 1177 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
 1178 
 1179 int
 1180 linux_chown(struct thread *td, struct linux_chown_args *args)
 1181 {
 1182         char *path;
 1183         int error;
 1184 
 1185         LCONVPATHEXIST(td, args->path, &path);
 1186 
 1187 #ifdef DEBUG
 1188         if (ldebug(chown))
 1189                 printf(ARGS(chown, "%s, %d, %d"), path, args->uid, args->gid);
 1190 #endif
 1191         error = kern_chown(td, path, UIO_SYSSPACE, args->uid, args->gid);
 1192         LFREEPATH(path);
 1193         return (error);
 1194 }
 1195 
 1196 int
 1197 linux_lchown(struct thread *td, struct linux_lchown_args *args)
 1198 {
 1199         char *path;
 1200         int error;
 1201 
 1202         LCONVPATHEXIST(td, args->path, &path);
 1203 
 1204 #ifdef DEBUG
 1205         if (ldebug(lchown))
 1206                 printf(ARGS(lchown, "%s, %d, %d"), path, args->uid, args->gid);
 1207 #endif
 1208         error = kern_lchown(td, path, UIO_SYSSPACE, args->uid, args->gid);
 1209         LFREEPATH(path);
 1210         return (error);
 1211 }

Cache object: fb16cb100361f9635c2e92f96aebcf7a


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.