sys/emulation/linux/linux_util.c

   1 /*
   2  * Copyright (c) 1994 Christos Zoulas
   3  * Copyright (c) 1995 Frank van der Linden
   4  * Copyright (c) 1995 Scott Bartram
   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  * 3. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  *      from: svr4_util.c,v 1.5 1995/01/22 23:44:50 christos Exp
  30  * $FreeBSD: src/sys/compat/linux/linux_util.c,v 1.12.2.2 2001/11/05 19:08:23 marcel Exp $
  31  * $DragonFly: src/sys/emulation/linux/linux_util.c,v 1.8 2003/11/13 04:04:42 daver Exp $
  32  */
  33
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/proc.h>
  37 #include <sys/namei.h>
  38 #include <sys/malloc.h>
  39 #include <sys/vnode.h>
  40
  41 #include "linux_util.h"
  42
  43 const char      linux_emul_path[] = "/compat/linux";
  44
  45 /*
  46  * Search for an alternate path before passing pathname arguments on
  47  * to system calls.
  48  *
  49  * Only signal an error if something really bad happens.  In most cases
  50  * we can just return the untranslated path, eg. name lookup failures.
  51  */
  52 int
  53 linux_copyin_path(char *uname, char **kname, int flags)
  54 {
  55         struct thread *td = curthread;
  56         struct nameidata nd, ndroot;
  57         struct vattr vat, vatroot;
  58         char *buf, *cp;
  59         int error, length, dummy;
  60
  61         buf = (char *) malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
  62         *kname = buf;
  63
  64         /*
  65          * Don't bother trying to translate if the path is relative.
  66          */
  67         if (fubyte(uname) != '/')
  68                 goto dont_translate;
  69
  70         /*
  71          * The path is absolute.  Prepend the buffer with the emulation
  72          * path and copy in.
  73          */
  74         length = strlen(linux_emul_path);
  75         bcopy(linux_emul_path, buf, length);
  76         error = copyinstr(uname, buf + length, MAXPATHLEN - length, &dummy);
  77         if (error) {
  78                 linux_free_path(kname);
  79                 return (error);
  80         }
  81
  82         switch (flags) {
  83         case LINUX_PATH_CREATE:
  84                 /*
  85                  * Check to see if the parent directory exists in the
  86                  * emulation tree.  Walk the string backwards to find
  87                  * the last '/'.
  88                  */
  89                 cp = buf + strlen(buf);
  90                 while (*--cp != '/');
  91                 *cp = '\0';
  92
  93                 NDINIT(&nd, NAMEI_LOOKUP, CNP_FOLLOW, UIO_SYSSPACE, buf, td);
  94                 error = namei(&nd);
  95                 if (error)
  96                         goto dont_translate;
  97
  98                 *cp = '/';
  99                 return (0);
 100         case LINUX_PATH_EXISTS:
 101                 NDINIT(&nd, NAMEI_LOOKUP, CNP_FOLLOW, UIO_SYSSPACE, buf, td);
 102                 error = namei(&nd);
 103                 if (error)
 104                         goto dont_translate;
 105
 106                 /*
 107                  * We now compare the vnode of the linux_root to the one
 108                  * vnode asked. If they resolve to be the same, then we
 109                  * ignore the match so that the real root gets used.
 110                  * This avoids the problem of traversing "../.." to find the
 111                  * root directory and never finding it, because "/" resolves
 112                  * to the emulation root directory. This is expensive :-(
 113                  *
 114                  * The next three function calls should not return errors.
 115                  * If they do something is seriously wrong, eg. the
 116                  * emulation subtree does not exist.  Cross our fingers
 117                  * and return the untranslated path if something happens.
 118                  */
 119                 NDINIT(&ndroot, NAMEI_LOOKUP, CNP_FOLLOW, UIO_SYSSPACE,
 120                     linux_emul_path, td);
 121                 error = namei(&ndroot);
 122                 if (error)
 123                         goto dont_translate;
 124
 125                 error = VOP_GETATTR(nd.ni_vp, &vat, td);
 126                 if (error)
 127                         goto dont_translate;
 128
 129                 error = VOP_GETATTR(ndroot.ni_vp, &vatroot, td);
 130                 if (error)
 131                         goto dont_translate;
 132
 133                 if (vat.va_fsid == vatroot.va_fsid &&
 134                     vat.va_fileid == vatroot.va_fileid)
 135                         goto dont_translate;
 136
 137                 return (0);
 138         default:
 139                 linux_free_path(kname);
 140                 return (EINVAL);
 141         }
 142
 143 dont_translate:
 144
 145         error = copyinstr(uname, buf, MAXPATHLEN, &dummy);
 146         if (error)
 147                 linux_free_path(kname);
 148         return (error);
 149 }
 150
 151 /*
 152  * Smaller version of the above for translating in kernel buffers.  Only
 153  * used in exec_linux_imgact_try().  Only check is path exists.
 154  */
 155 int
 156 linux_translate_path(char *path, int size)
 157 {
 158         struct thread *td = curthread;
 159         struct nameidata nd;
 160         char *buf;
 161         int error, length, dummy;
 162
 163         buf = (char *) malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 164         length = strlen(linux_emul_path);
 165         bcopy(linux_emul_path, buf, length);
 166         error = copystr(path, buf + length, MAXPATHLEN - length, &dummy);
 167         if (error)
 168                 goto cleanup;
 169
 170         /*
 171          * If this errors, then the path probably doesn't exists.
 172          */
 173         NDINIT(&nd, NAMEI_LOOKUP, CNP_FOLLOW, UIO_SYSSPACE, buf, td);
 174         error = namei(&nd);
 175         if (error) {
 176                 error = 0;
 177                 goto cleanup;
 178         }
 179
 180         /*
 181          * The alternate path does exist.  Return it in the buffer if
 182          * it fits.
 183          */
 184         if (strlen(buf) + 1 <= size)
 185                 error = copystr(buf, path, size, &dummy);
 186
 187 cleanup:
 188
 189         free(buf, M_TEMP);
 190         return (error);
 191 }